const express = require('express');
const http = require('http');
const { Server } = require('socket.io');
const { v4: uuidv4 } = require('uuid');

const app = express();
const path = require('path');
const server = http.createServer(app);
const io = new Server(server, { cors: { origin: '*' } });

app.use(express.json());
app.use(express.static('public'));
// Serve provided assets (piece sets, boards, etc.) under /assets
app.use('/assets', express.static(path.join(__dirname, 'assets')));

// Public API: list available cards (uses the same deck builder as the server)
app.get('/cards', (req, res) => {
  try{
    const deck = buildDefaultDeck() || [];
    // Return a lightweight view (id, cardId, title, description)
    const out = deck.map(c => ({ id: c.id, cardId: c.cardId, title: c.title, description: c.description }));
    res.json({ ok: true, cards: out });
  }catch(e){ console.error('GET /cards error', e); res.status(500).json({ error: 'server_error' }); }
});

// In-memory rooms store. For production replace with persistent store.
// room = { id, boardState: object|null, players: [{id, socketId, color}], status, size }
const rooms = new Map();

// Send a room:update payload to each player individually so hands remain private.
function sendRoomUpdate(room){
  if(!room) return;
  const base = {
    boardState: room.boardState || null,
    players: (room.players || []).map(p => ({ id: p.id, color: p.color })),
    status: room.status,
    hostId: room.hostId,
    size: (room.boardState && room.boardState.width) || room.size,
    cards: Object.keys(room.cards || {}),
    autoDraw: !!room.autoDraw,
    noRemise: !!room.noRemise,
    deckCount: (room.deck && room.deck.length) || 0,
    discardCount: (room.discard && room.discard.length) || 0
  };

  const handCounts = {};
  (room.players || []).forEach(p => { handCounts[p.id] = (room.hands && room.hands[p.id] ? room.hands[p.id].length : 0); });

  (room.players || []).forEach(p => {
    const payload = Object.assign({}, base, {
      // expose only the recipient's own hand
      handsOwn: (room.hands && room.hands[p.id]) ? room.hands[p.id] : [],
      handCounts
    });
    // Create a per-recipient boardState view that only hides pieces targeted by an 'invisible' effect
    try{
      if(base.boardState && base.boardState.pieces && Array.isArray(base.boardState.pieces)){
        const filtered = Object.assign({}, base.boardState);
        filtered.pieces = (base.boardState.pieces || []).filter(piece => {
          try{
            // If a piece has an explicit invisible flag, hide it from recipients who are not the owner
            if(piece.invisible){
              const ownerPlayer = (room.players || []).find(pl => (pl.color && pl.color[0]) === piece.color);
              const ownerId = ownerPlayer && ownerPlayer.id;
              if(ownerId && ownerId !== p.id) return false;
            }
            // If an 'invisible' active effect targets this piece, hide it from recipients who are not the effect owner
            const inv = (room.activeCardEffects || []).find(e => e && e.type === 'invisible' && (e.pieceId === piece.id || e.pieceSquare === piece.square));
            if(inv && inv.playerId && inv.playerId !== p.id){
              return false; // hide this piece for this recipient
            }
            return true;
          }catch(_){ return true; }
        });
        payload.boardState = filtered;
      } else {
        payload.boardState = base.boardState || null;
      }
    }catch(_){ payload.boardState = base.boardState || null; }
    // attach visible squares for this recipient (fog of war)
    try{
      payload.visibleSquares = Array.from(visibleSquaresForPlayer(room, p.id) || []);
      // attach any mines owned by this recipient (mines are hidden from other players)
      try{
        const mines = (room.activeCardEffects || []).filter(e => e.type === 'mine' && e.playerId === p.id).map(e => e.square);
        payload.minesOwn = mines;
      }catch(_){ payload.minesOwn = []; }
    }catch(e){ payload.visibleSquares = []; }
    // attach captured pieces that belong to this recipient so they may choose one for resurrection
    try{
      const shortColor = (p.color && p.color[0]) || null;
      payload.capturedOwn = (room.captured || []).filter(c => c && c.piece && c.piece.color === shortColor).map(c => ({ id: c.id, type: c.piece.type, originalId: c.piece.id, originalSquare: c.piece.square, capturedBy: c.capturedBy, ts: c.ts }));
    }catch(_){ payload.capturedOwn = []; }
    if(p.socketId){
      io.to(p.socketId).emit('room:update', payload);
    }
  });
}

// Helper: at the start of a player's turn, either perform an automatic draw
// if room.autoDraw is enabled, or simply broadcast the room state so clients
// can update UI. This centralizes the auto-draw toggle behavior.
function maybeDrawAtTurnStart(room, playerId){
  try{
    if(!room) return;
    if(room.autoDraw){
      drawCardForPlayer(room, playerId);
    } else {
      // ensure clients get the updated room state even if no draw happens
      sendRoomUpdate(room);
    }
  }catch(e){ console.error('maybeDrawAtTurnStart error', e); sendRoomUpdate(room); }
}

// Compute the set of squares visible to a given player (adjacent to any of their pieces).
// Returns a Set of square strings (e.g., 'e4').
function visibleSquaresForPlayer(room, playerId){
  const out = new Set();
  if(!room || !room.boardState || !playerId) return out;
  const state = room.boardState;
  const width = state.width || 8;
  const height = state.height || 8;
  function squareToCoord(sq){
    if(!sq) return null;
    const s = String(sq).trim().toLowerCase();
    if(!/^[a-z][1-9][0-9]*$/.test(s)) return null;
    const file = s.charCodeAt(0) - 'a'.charCodeAt(0);
    const rank = parseInt(s.slice(1),10) - 1; // 0-indexed
    return { x: file, y: rank };
  }
  function coordToSquare(x,y){ if(x<0||y<0||x>=width||y>=height) return null; return String.fromCharCode('a'.charCodeAt(0) + x) + (y+1); }
  // find the player color for playerId
  const player = (room.players || []).find(p => p.id === playerId);
  if(!player) return out;
  const colorShort = (player.color && player.color[0]) || null;
  // iterate pieces belonging to player
  (state.pieces || []).forEach(piece => {
    if(piece.color !== colorShort) return;
    const c = squareToCoord(piece.square);
    if(!c) return;
    for(let dx=-1; dx<=1; dx++) for(let dy=-1; dy<=1; dy++){
      const nx = c.x + dx, ny = c.y + dy;
      const sq = coordToSquare(nx, ny);
      if(sq) out.add(sq);
    }
  });
  return out;
}

// Helper to end a player's turn after playing a card: flip turn, decrement per-turn effects and trigger next player's draw
function endTurnAfterCard(room, senderId){
  try{
    if(!room || !room.boardState) return;
    const board = room.boardState;
    // flip turn
    if(board.turn) board.turn = (board.turn === 'w') ? 'b' : 'w';
    // decrement remainingTurns for any time-limited effects that belong to the player who just finished their turn
    try{
      room.activeCardEffects = room.activeCardEffects || [];
      for(let i = room.activeCardEffects.length - 1; i >= 0; i--){
        const e = room.activeCardEffects[i];
        if(typeof e.remainingTurns === 'number'){
          let shouldDecrement = false;
          if(e.decrementOn === 'opponent'){
            shouldDecrement = (e.playerId !== senderId);
          } else if(e.decrementOn === 'owner'){
            shouldDecrement = (e.playerId === senderId);
          } else {
            shouldDecrement = (e.playerId === senderId);
          }
          if(shouldDecrement){
            e.remainingTurns = e.remainingTurns - 1;
            try{ io.to(room.id).emit('card:effect:updated', { roomId: room.id, effect: e }); }catch(_){ }
            if(e.remainingTurns <= 0){ room.activeCardEffects.splice(i,1); try{ io.to(room.id).emit('card:effect:removed', { roomId: room.id, effectId: e.id, type: e.type, playerId: e.playerId }); }catch(_){ } }
          }
        }
      }
    }catch(e){ console.error('updating temporary effects error', e); }

    // reset per-turn card-play flags
    try{ room._cardPlayedThisTurn = {}; }catch(_){ }

    // perform next player's draw (if autoDraw) or at least send room update
    try{ 
      const nextColor = board.turn;
      const nextPlayer = room.players.find(p => (p.color && p.color[0]) === nextColor);
      if(nextPlayer){ maybeDrawAtTurnStart(room, nextPlayer.id); } else { sendRoomUpdate(room); }
    }catch(_){ sendRoomUpdate(room); }
  }catch(e){ console.error('endTurnAfterCard error', e); }
}

// Check if a king is missing and end the game. Returns an object describing the outcome or null if game continues.
function checkAndHandleVictory(room){
  try{
    if(!room || !room.boardState) return null;
    // if the room is already finished, don't re-emit or change state
    if(room.status === 'finished') return null;
    const pieces = room.boardState.pieces || [];
    const hasWhiteKing = pieces.some(p => p && p.type && String(p.type).toUpperCase() === 'K' && p.color === 'w');
    const hasBlackKing = pieces.some(p => p && p.type && String(p.type).toUpperCase() === 'K' && p.color === 'b');
    if(hasWhiteKing && hasBlackKing) return null;
    // both missing -> draw
    if(!hasWhiteKing && !hasBlackKing){
      room.status = 'finished';
      try{ io.to(room.id).emit('game:over', { roomId: room.id, draw: true, boardState: room.boardState }); }catch(_){ }
      return { over: true, draw: true };
    }
    const winnerColor = hasWhiteKing ? 'w' : 'b';
    const loserColor = hasWhiteKing ? 'b' : 'w';
    const winner = (room.players || []).find(p => (p.color && p.color[0]) === winnerColor) || null;
    const loser = (room.players || []).find(p => (p.color && p.color[0]) === loserColor) || null;
    room.status = 'finished';
    try{ io.to(room.id).emit('game:over', { roomId: room.id, winnerId: winner && winner.id, loserId: loser && loser.id, winnerColor, boardState: room.boardState }); }catch(_){ }
    return { over: true, winnerId: winner && winner.id, loserId: loser && loser.id, winnerColor };
  }catch(e){ console.error('checkAndHandleVictory error', e); return null; }
}

// Build a default deck from README list. Each card has a unique id, cardId (slug), title and description.
function buildDefaultDeck(){
  const cards = [
    // ['tronquer le plateau','Tronque au maximum le plateau sans supprimer de pièce'],
    ['rebondir sur les bords','Les déplacements en diagonales de la pièce sélectionnée peuvent rebondir une fois sur les bords'],
    // ['agrandir le plateau','Rajoute une rangée dans toutes les directions'],
    ['adoubement','La pièce sélectionnée peut maintenant faire les déplacements du cavalier en plus'],
    ['folie','La pièce sélectionnée peut maintenant faire les déplacements du fou en plus'],
    ['fortification','La pièce sélectionnée peut maintenant faire les déplacements de la tour en plus'],
    ["l'anneau","Le plateau devient un anneau pendant un tour"],
    // ['brouillard de guerre','Les joueur ne peuvent voir que au alentour de leurs pièces pendant 4 tours'],
    // ['changer la pièce à capturer','Le joueur choisie la nouvelle pièce jouant le rôle de roi sans la révéler'],
    // ['trou de ver','Deux cases du plateau deviennent maintenant la même'],
    ['jouer deux fois','Le joueur peut déplacer deux pièces'],
    // ['annulation d une carte','Annule l effet d une carte qui est jouée par l adversaire'],
    ['placement de mines','Le joueur place une mine sur une case vide sans la révéler au joueur adverse. Une pièce qui se pose dessus explose et est capturée par le joueur ayant placé la mine'],
    ['vole d une pièce','Désigne une pièce non roi qui change de camp.\n\nCompte comme un mouvement'],
    ['promotion','Un pion au choix est promu'],
    ['vole d une carte','Vole une carte aléatoirement au joueur adverse'],
    ['resurection','Ressucite la dernière pièce perdue'],
    ['carte sans effet',"N'a aucun effet"],
    // ['défausse','Le joueur adverse défausse une carte de son choix'],
    // ['immunité à la capture','Désigne une pièce qui ne pourra pas être capturée au prochain tour'],
    ['kamikaz','Détruit une de ses pièces, détruisant toutes les pièces adjacentes.\n\nCompte comme un mouvement'],
    // ['retour à la case départ','Désigne une pièce qui retourne à sa position initiale'],
    // ['glissade','La pièce désignée ne peut plus s arrêter si elle se déplace en diagonale ou en ligne droite. Soit elle percute une pièce et la capture, soit elle tombe du plateau et est capturée'],
    ['invisible',"Une des pièces devient invisible pour l'adversaire"],
    // ['épidémie','Toutes les pièces sur le territoire enemie est est capturée'],
    // ['glue','Toutes les pièces autour de la pièce désignée ne peuvent pas bouger tant que cette dernière ne bouge pas'],
    ["coin coin","Possibilité de se téléporter depuis un coin vers n'importe quel autre coin"],
    ['téléportation',"Téléporte n'importe quelle pièce de son camp sur une case vide"],
    ['changement de camp','On retourne le plateau'],
    // ['ça tangue','Toutes les pièces se décale du même côté'],
    // ['réinitialisation','Toutes les pièces reviennent à leur position initiale. S il y a des pièces supplémenaires, se rangent devant les pions'],
    ["toucher c'est jouer","Toucher une pièce adverse qu'il sera obligé de jouer"],
    // ['marécage','Pendant X tours, toutes les pièces ne peuvent se déplacer que comme un roi'],
    ['sniper','Capturer une pièce sans avoir à bouger la pièce capturante'],
    ['inversion',"Échange la position d'une pièce avec une pièce adverse.\n\nCompte comme un mouvement"],
    // ['jeu des 7 différences','Déplace une pièce du plateau pendant que le joueur adverse à les yeux fermés. S il la retrouve, elle est capturée, laissée sinon'],
    // ['punching ball','Replace le roi dans sa position initiale, et place un nouveau pion à l ancienne position du roi'],
    // ['reversi','Si deux pions encadrent parfaitement une pièce adverse, cette dernière change de camp'],
    // ['plus on est de fous','Si le joueur possède deux fous dans la même diagonale, alors toutes les pièces adverses encadrées par ces deux fous sont capturés'],
    // ['cluster','Désigne 4 pions formant un rectangle. Tant que ces pions ne bougent pas, aucune pièce ne peut sortir ou rentrer dans ce rectangle.'],
    // ['vacances','Choisie une pièce qui sort du plateau pendant deux tours. Ce après quoi elle tente de revenir: si la case est occupée, alors la pièce vacancière est capturée par la pièce occupant la case.'],
    ['mélange','La position de toutes les pièces sont échangées aléatoirement'],
    ['la parrure','Une reine est dégradée en pion'],
    // ['tricherie','Choisis une carte de la pioche parmis trois'],
    ['tout ou rien','Une pièce choisie ne peut maintenant se déplacer que si elle capture.'],
    // ['tous les mêmes','Au yeux de l ennemie, toutes les pièces se ressemblent pendant 2 tours.'],
    // ['petit pion','Le joueur choisit un pion. À partir du prochain tour, il est promu en reine dès qu il capture un pièce non pion.'],
    ['révolution','Tous les pions sont aléatoirement changés en Cavalier, Fou ou Tour et les Cavaliers, Fous et Tours sont changés en pions.'],
    // ['doppelganger','Choisis une pièce. À partir de maintenant, devient chacune des pièces qu elle capture.'],
    // ['kurby','Choisis une pièce. À sa prochaine capture, récupère les mouvements de la pièce capturée.']
  ];
  function cap(s){ if(!s) return s; s = String(s).trim(); return s.charAt(0).toUpperCase() + s.slice(1); }
  return cards.map(([title,desc])=>{
    const normalized = (title||'').toString().trim();
    // generate an ASCII-friendly slug by removing diacritics before replacing non-alphanumerics
    let ascii = normalized;
    try{ ascii = ascii.normalize('NFD').replace(/\p{Diacritic}/gu, ''); }catch(e){ /* ignore if normalize unsupported */ }
    const cardId = ascii.replace(/[^a-z0-9]+/gi,'_').toLowerCase();
    return { id: uuidv4().slice(0,8), cardId, title: cap(normalized), description: desc };
  });
}

// draw a random card from room.deck and assign to player hand (respect max hand size 5)
function drawCardForPlayer(room, playerId){
  if(!room) return null;
  // ensure deck exists for legacy rooms
  room.deck = room.deck || buildDefaultDeck();
  room.hands = room.hands || {};
  room.deck = room.deck || [];
  const hand = room.hands[playerId] || [];
  // avoid drawing more than once for the same board version
  room._lastDrawForPlayer = room._lastDrawForPlayer || {};
  const boardVersion = (room.boardState && room.boardState.version) || null;
  if(boardVersion !== null && room._lastDrawForPlayer[playerId] === boardVersion){
    // already drew for this version
    return null;
  }
  if(hand.length >= 5) return null; // hand full
  if(room.deck.length === 0){
    // if deck empty, try to refill from discard and shuffle — unless 'noRemise' is enabled
    if(!room.noRemise && room.discard && room.discard.length > 0){
      // move all discard into deck
      room.deck = room.discard.splice(0).concat(room.deck || []);
      // simple Fisher-Yates shuffle
      for(let i = room.deck.length - 1; i > 0; i--){
        const j = Math.floor(Math.random() * (i + 1));
        const tmp = room.deck[i]; room.deck[i] = room.deck[j]; room.deck[j] = tmp;
      }
      // notify players that the deck was reshuffled
      (room.players || []).forEach(p => { if(p.socketId) io.to(p.socketId).emit('deck:reshuffled', { roomId: room.id, deckCount: room.deck.length }); });
    }
  }
  if(room.deck.length === 0) return null; // no cards even after reshuffle
  // shuffle deck before drawing (always shuffle to ensure randomness)
  for(let i = room.deck.length - 1; i > 0; i--){
    const j = Math.floor(Math.random() * (i + 1));
    const tmp = room.deck[i]; room.deck[i] = room.deck[j]; room.deck[j] = tmp;
  }
  // pick random index from the freshly shuffled deck
  const idx = Math.floor(Math.random() * room.deck.length);
  const card = room.deck.splice(idx,1)[0];
  // normalize title capitalization just in case this deck was created earlier with inconsistent casing
  if(card && card.title){
    card.title = String(card.title).trim();
    card.title = card.title.charAt(0).toUpperCase() + card.title.slice(1);
  }
  room.hands[playerId] = room.hands[playerId] || [];
  room.hands[playerId].push(card);
  if(boardVersion !== null) room._lastDrawForPlayer[playerId] = boardVersion;
  // emit card drawn and updated room state
  // send card:drawn only to the recipient
  const recipient = (room.players || []).find(p => p.id === playerId);
  if(recipient && recipient.socketId){
    io.to(recipient.socketId).emit('card:drawn', { playerId, card });
  }
  // send personalized room updates to all players
  sendRoomUpdate(room);
  return card;
}
// Placeholder: compute legal moves for a square in the given room.
// `boardState` is the canonical JSON representation of the board for this server.
// Example boardState: { width:8, height:8, turn:'w', version:1, pieces: [{ square:'e2', type:'P', color:'w', id:'w_p1' }, ... ] }
function computeLegalMoves(room, square){
  // Basic pseudo-legal move generator for standard chess-like pieces.
  // - Does not perform check detection (moves that leave king in check are allowed).
  // - Does not implement castling or en-passant.
  // - Returns moves as array of { from, to }.
  if(!room || !room.boardState || !square) return [];
  const state = room.boardState;
  const width = state.width || 8;
  const height = state.height || 8;

  // helpers
  function squareToCoord(sq){
    if(!sq) return null;
    const s = String(sq).trim().toLowerCase();
    if(!/^[a-z][1-9][0-9]*$/.test(s)) return null;
    const file = s.charCodeAt(0) - 'a'.charCodeAt(0);
    const rank = parseInt(s.slice(1),10) - 1; // 0-indexed
    return { x: file, y: rank };
  }
  function coordToSquare(x,y){
    if(x < 0 || y < 0 || x >= width || y >= height) return null;
    return String.fromCharCode('a'.charCodeAt(0) + x) + (y+1);
  }
  function getPieceAt(sq){
    if(!sq) return null;
    return (state.pieces || []).find(p => p.square === sq) || null;
  }
  function isInside(x,y){ return x >= 0 && y >= 0 && x < width && y < height; }

  const piece = getPieceAt(square);
  if(!piece) return [];
  const color = piece.color; // 'w' or 'b'
  const fromCoord = squareToCoord(square);
  if(!fromCoord) return [];
  const moves = [];

  // add move helper
  function pushIfEmptyOrCapture(tx,ty){
    if(!isInside(tx,ty)) return false;
    const toSq = coordToSquare(tx,ty);
    const occupant = getPieceAt(toSq);
    if(!occupant){
      moves.push({ from: square, to: toSq });
      return true; // can continue sliding
    }
    // capture allowed if different color
    if(occupant.color !== color){
      moves.push({ from: square, to: toSq });
    }
    return false; // blocked
  }

  const x = fromCoord.x, y = fromCoord.y;
  const type = (piece.type || '').toUpperCase();
  // If this piece has been granted corner-teleport moves by 'coincoin', include those allowed squares
  try{
    const coin = (room.activeCardEffects || []).find(e => e && e.type === 'coincoin' && ((e.pieceId && e.pieceId === piece.id) || e.pieceSquare === square));
    if(coin && Array.isArray(coin.allowedSquares) && coin.allowedSquares.length > 0){
      coin.allowedSquares.forEach(sq => {
        try{
          // only add empty corner squares (do not allow capture via coincoin)
          if(!moves.some(m => m.to === sq)){
            const occ = getPieceAt(sq);
            if(!occ) moves.push({ from: square, to: sq });
          }
        }catch(_){ }
      });
    }
  }catch(_){ }
  // detect teleport effect: allow this piece to move to any empty square (one-turn temporary effect)
  try{
    const hasTeleport = (room.activeCardEffects || []).some(e => e && e.type === 'teleport' && ((e.pieceId && e.pieceId === piece.id) || e.pieceSquare === square));
    if(hasTeleport){
      // iterate all board squares and add empty ones as legal non-capturing moves
      for(let tx = 0; tx < width; tx++){
        for(let ty = 0; ty < height; ty++){
          const tsq = coordToSquare(tx, ty);
          if(!tsq) continue;
          // avoid adding the current square
          if(tsq === square) continue;
          const occ = getPieceAt(tsq);
          if(!occ && !moves.some(m => m.to === tsq)){
            moves.push({ from: square, to: tsq });
          }
        }
      }
    }
  }catch(_){ }
  // detect if this specific piece has a permanent adoubement effect (grants knight moves)
  // effects may be bound either to the piece's current square or to the piece id (preferred)
  const hasAdoubement = (room.activeCardEffects || []).some(e => e.type === 'adoubement' && ((e.pieceId && e.pieceId === piece.id) || e.pieceSquare === square));

  // helper to add knight (N) deltas when a piece has been adoubé
  function addAdoubementMoves(){
    if(!hasAdoubement) return;
    const deltas = [[1,2],[2,1],[-1,2],[-2,1],[1,-2],[2,-1],[-1,-2],[-2,-1]];
    deltas.forEach(([dx,dy])=>{
      const tx = x + dx, ty = y + dy;
      const tsq = resolveSquareWithAnneau(tx, ty);
      if(!tsq) return;
      // avoid duplicates
      if(moves.some(m => m.to === tsq)) return;
      const occ = getPieceAt(tsq);
      if(!occ || occ.color !== color) moves.push({ from: square, to: tsq });
    });
  }
  // detect if this specific piece has a permanent folie effect (grants bishop moves)
  const hasFolie = (room.activeCardEffects || []).some(e => e.type === 'folie' && ((e.pieceId && e.pieceId === piece.id) || e.pieceSquare === square));

  // detect if this specific piece has a permanent fortification effect (grants rook moves)
  const hasFortification = (room.activeCardEffects || []).some(e => e.type === 'fortification' && ((e.pieceId && e.pieceId === piece.id) || e.pieceSquare === square));

  // detect if the owner of this piece currently has an active 'anneau' effect
  const anneauPlayers = (room.activeCardEffects || []).filter(e => e.type === 'anneau').map(e => e.playerId);
  const ownerPlayer = (room.players || []).find(p => (p.color && p.color[0]) === piece.color);
  const hasAnneau = ownerPlayer && anneauPlayers.indexOf(ownerPlayer.id) !== -1;

  // helper to resolve a target square, allowing horizontal wrap when anneau is active for this piece
  function resolveSquareWithAnneau(tx, ty){
    // inside bounds
    if(isInside(tx, ty)) return coordToSquare(tx, ty);
    // allow only horizontal wrap (left/right) when anneau is active for this piece's owner
    if(!hasAnneau) return null;
    if(ty < 0 || ty >= height) return null; // no vertical wrapping
    if(tx < 0 || tx >= width){
      const wx = ((tx % width) + width) % width;
      return coordToSquare(wx, ty);
    }
    return null;
  }

  // filter moves according to brouillard (fog of war) if it is active for the owner of this piece
  function filterMovesByFog(moves){
    try{
      const owner = ownerPlayer;
      if(!owner) return moves;
      const hasBrouillard = (room.activeCardEffects || []).some(e => e.type === 'brouillard' && e.playerId === owner.id);
      if(!hasBrouillard) return moves;
      const vis = visibleSquaresForPlayer(room, owner.id);
      return (moves || []).filter(m => vis.has(m.to));
    }catch(e){ return moves; }
  }

  // helper to add diagonal sliding moves when a piece has been "folié"
  function addFolieMoves(){
    if(!hasFolie) return;
    const dirs = [[1,1],[1,-1],[-1,1],[-1,-1]];
    dirs.forEach(([dx,dy])=>{
      let tx = x + dx, ty = y + dy;
      let wrapped = false;
      while(true){
        // resolve target square with anneau
        let tsq = null;
        if(isInside(tx,ty)){
          tsq = coordToSquare(tx,ty);
        } else if(hasAnneau && (tx < 0 || tx >= width) && ty >= 0 && ty < height && !wrapped){
          const wx = ((tx % width) + width) % width;
          tsq = coordToSquare(wx, ty);
          tx = wx;
          wrapped = true;
        } else {
          break;
        }
        // avoid duplicates
        if(!moves.some(m => m.to === tsq)){
          const occ = getPieceAt(tsq);
          if(!occ){ moves.push({ from: square, to: tsq }); }
          else { if(occ.color !== color) moves.push({ from: square, to: tsq }); break; }
        } else {
          // if duplicate found, still need to stop sliding if occupied
          const occ = getPieceAt(tsq);
          if(occ) break;
        }
        tx += dx; ty += dy;
      }
    });
  }
  // helper to add orthogonal sliding moves when a piece has been 'fortifié'
  function addFortificationMoves(){
    if(!hasFortification) return;
    const dirs = [[1,0],[-1,0],[0,1],[0,-1]];
    dirs.forEach(([dx,dy])=>{
      let tx = x + dx, ty = y + dy;
      let wrapped = false;
      while(true){
        let tsq = null;
        if(isInside(tx,ty)){
          tsq = coordToSquare(tx,ty);
        } else if(hasAnneau && (tx < 0 || tx >= width) && ty >= 0 && ty < height && !wrapped){
          const wx = ((tx % width) + width) % width;
          tsq = coordToSquare(wx, ty);
          tx = wx;
          wrapped = true;
        } else {
          break;
        }
        if(!moves.some(m => m.to === tsq)){
          const occ = getPieceAt(tsq);
          if(!occ){ moves.push({ from: square, to: tsq }); }
          else { if(occ.color !== color) moves.push({ from: square, to: tsq }); break; }
        } else {
          const occ = getPieceAt(tsq);
          if(occ) break;
        }
        tx += dx; ty += dy;
      }
    });
  }
  if(type === 'P'){
    // pawn
    const forward = (color === 'w') ? 1 : -1;
    const startRank = (color === 'w') ? 1 : (height - 2);
    const oneY = y + forward;
    const oneSq = coordToSquare(x, oneY);
    if(isInside(x, oneY) && !getPieceAt(oneSq)){
      moves.push({ from: square, to: oneSq });
      // double push from starting rank
      const twoY = y + forward*2;
      const twoSq = coordToSquare(x, twoY);
      if(y === startRank && isInside(x, twoY) && !getPieceAt(twoSq)){
        moves.push({ from: square, to: twoSq });
      }
    }
    // captures
    [[x-1, y+forward],[x+1, y+forward]].forEach(([tx,ty])=>{
      const tsq = resolveSquareWithAnneau(tx, ty);
      if(!tsq) return;
      const occ = getPieceAt(tsq);
      if(occ && occ.color !== color) moves.push({ from: square, to: tsq });
    });
    addAdoubementMoves(); addFolieMoves(); addFortificationMoves();
    return filterMovesByFog(moves);
  }

  if(type === 'N'){
    const deltas = [[1,2],[2,1],[-1,2],[-2,1],[1,-2],[2,-1],[-1,-2],[-2,-1]];
    deltas.forEach(([dx,dy])=>{
      const tx = x + dx, ty = y + dy;
      const tsq = resolveSquareWithAnneau(tx, ty);
      if(!tsq) return;
      const occ = getPieceAt(tsq);
      if(!occ || occ.color !== color) moves.push({ from: square, to: tsq });
    });
    addAdoubementMoves(); addFolieMoves(); addFortificationMoves();
    return filterMovesByFog(moves);
  }

  if(type === 'B' || type === 'Q' || type === 'R'){
    const directions = [];
    if(type === 'B' || type === 'Q') directions.push([1,1],[1,-1],[-1,1],[-1,-1]);
    if(type === 'R' || type === 'Q') directions.push([1,0],[-1,0],[0,1],[0,-1]);

  // detect if this specific piece has an active rebondir effect (match by id or square)
  const hasRebond = (room.activeCardEffects || []).some(e => e.type === 'rebondir' && ((e.pieceId && e.pieceId === piece.id) || e.pieceSquare === square));

    directions.forEach(([dx0,dy0])=>{
      if(!hasRebond){
        // standard sliding behavior, with optional single horizontal wrap when anneau is active
        let tx = x + dx0, ty = y + dy0;
        let wrapped = false;
        while(true){
          // resolve target taking anneau into account
          let tsq = null;
          if(isInside(tx,ty)){
            tsq = coordToSquare(tx,ty);
          } else if(hasAnneau && (tx < 0 || tx >= width) && ty >= 0 && ty < height && !wrapped){
            const wx = ((tx % width) + width) % width;
            tsq = coordToSquare(wx, ty);
            // set tx to wrapped coordinate so further increments continue correctly
            tx = wx;
            wrapped = true;
          } else {
            break;
          }

          const occ = getPieceAt(tsq);
          if(!occ){
            moves.push({ from: square, to: tsq });
            // advance current position along the direction
            tx += dx0; ty += dy0;
            continue;
          }
          // occupied
          if(occ.color !== color) moves.push({ from: square, to: tsq });
          break;
        }
      } else {
        // sliding with a single bounce on edges (mirror reflection once)
        let dx = dx0, dy = dy0;
        let cx = x, cy = y; // current position while sliding
        let bounced = false;
        while(true){
          let tx = cx + dx, ty = cy + dy;
          if(!isInside(tx,ty)){
            if(bounced) break; // already used bounce
            // reflect the direction components that would go out of bounds
            if(tx < 0 || tx >= width) dx = -dx;
            if(ty < 0 || ty >= height) dy = -dy;
            bounced = true;
            // recompute the next square after reflection from current position
            tx = cx + dx; ty = cy + dy;
            if(!isInside(tx,ty)) break; // still invalid after reflection
          }
          const tsq = coordToSquare(tx,ty);
          const occ = getPieceAt(tsq);
          if(!occ){
            moves.push({ from: square, to: tsq });
            // advance current position along the (possibly reflected) direction
            cx = tx; cy = ty;
            continue;
          }
          // occupied
          if(occ.color !== color) moves.push({ from: square, to: tsq });
          break;
        }
      }
    });
    addAdoubementMoves(); addFolieMoves(); addFortificationMoves();
    return filterMovesByFog(moves);
  }

  if(type === 'K'){
    for(let dx=-1; dx<=1; dx++) for(let dy=-1; dy<=1; dy++){
      if(dx === 0 && dy === 0) continue;
      const tx = x + dx, ty = y + dy;
      const tsq = resolveSquareWithAnneau(tx, ty);
      if(!tsq) continue;
      const occ = getPieceAt(tsq);
      if(!occ || occ.color !== color) moves.push({ from: square, to: tsq });
    }
    addAdoubementMoves(); addFolieMoves();
    return filterMovesByFog(moves);
  }

  addAdoubementMoves(); addFolieMoves(); addFortificationMoves();
  return filterMovesByFog(moves);
}

function startingBoardState8(){
  // returns a simple pieces array with square names for standard chess starting position
  const rows = [
    'rnbqkbnr',
    'pppppppp',
    '........',
    '........',
    '........',
    '........',
    'PPPPPPPP',
    'RNBQKBNR'
  ];
  const pieces = [];
  for(let r=0;r<8;r++){
    const row = rows[r];
    for(let f=0;f<8;f++){
      const ch = row[f];
      if(ch === '.') continue;
      const fileLetter = String.fromCharCode('a'.charCodeAt(0) + f);
      const rank = 8 - r;
      const square = `${fileLetter}${rank}`;
      const isWhite = (ch === ch.toUpperCase());
      const type = ch.toUpperCase();
      const color = isWhite ? 'w' : 'b';
      const id = (color === 'w' ? 'w_' : 'b_') + type + '_' + pieces.length;
      pieces.push({ square, type, color, id });
    }
  }
  return { width: 8, height: 8, turn: 'w', version: 1, pieces };
}

app.post('/rooms', (req, res) => {
  const id = uuidv4().slice(0, 8);
  // allow optional board size in request body (default 8)
  const size = (req.body && parseInt(req.body.size, 10)) || 8;
  // For standard 8x8 we initialize a boardState JSON as the canonical board state.
  const boardState = size === 8 ? startingBoardState8() : null;
  // hostId will be set when the first player joins
  // initialize a deck for this room
  const deck = buildDefaultDeck();
  rooms.set(id, { id, boardState, players: [], status: 'waiting', hostId: null, size, cards: {}, playedCards: [], removalTimers: new Map(), deck, hands: {}, autoDraw: false, noRemise: false });
  res.json({ roomId: id, size });
});

app.get('/rooms/:id', (req, res) => {
  const room = rooms.get(req.params.id);
  if (!room) return res.status(404).json({ error: 'room not found' });
    const boardState = room.boardState || null;
    const size = (room.boardState && room.boardState.width) || room.size;
  res.json({ id: room.id, boardState, size: size, players: room.players.map(p => ({ id: p.id, color: p.color })), status: room.status, hostId: room.hostId, cards: Object.keys(room.cards || {}), autoDraw: !!room.autoDraw, noRemise: !!room.noRemise });
});

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

  socket.on('room:join', ({ roomId, playerId }, cb) => {
    const room = rooms.get(roomId);
    if (!room) return cb && cb({ error: 'room not found' });
  const assignedId = playerId || uuidv4();

    // If this player was pending removal (disconnect during navigation), cancel removal
    if(room.removalTimers && room.removalTimers.has(assignedId)){
      clearTimeout(room.removalTimers.get(assignedId));
      room.removalTimers.delete(assignedId);
    }

    // If playerId corresponds to an existing player, treat this as a reconnection
    let existing = room.players.find(p => p.id === assignedId);

    let color;
    if(existing){
      existing.socketId = socket.id;
      color = existing.color;
    } else {
      color = room.players.length === 0 ? 'white' : 'black';
      room.players.push({ id: assignedId, socketId: socket.id, color });
    }
    // ensure hands map exists
    room.hands = room.hands || {};
    // ensure deck exists for legacy rooms
    if(!room.deck) room.deck = buildDefaultDeck();
    // Note: starter card removed. Previously the first joining player received an 'Agrandir le plateau' starter card here.
    // The starter card was removed to avoid duplicate/unused cards in gameplay.
    socket.join(roomId);
    socket.data.roomId = roomId;
    socket.data.playerId = assignedId;

    // set hostId when first player joins
    if (!room.hostId) room.hostId = assignedId;


    sendRoomUpdate(room);

    // If the game is already playing and it's this player's turn, attempt to draw (useful on reconnect)
    // Only draw if the player's hand is currently empty to avoid double-drawing (e.g. initial granted cards)
    try{
        if(room.status === 'playing' && room.boardState && room.boardState.turn){
        const myPlayer = room.players.find(p => p.id === assignedId);
        const myShort = (myPlayer && myPlayer.color || '')[0];
        if(myShort === room.boardState.turn){
          const hasHand = room.hands && room.hands[assignedId] && room.hands[assignedId].length > 0;
          if(!hasHand) maybeDrawAtTurnStart(room, assignedId);
        }
      }
    }catch(e){ console.error('post-join draw error', e); }
    cb && cb({ ok: true, color, roomId, playerId: assignedId, hostId: room.hostId });
  });

  // Allow a client to voluntarily leave a room (immediate removal). This differs from
  // disconnect which waits briefly to allow quick reconnects.
  socket.on('room:leave', ({ roomId }, cb) => {
    try{
      const room = rooms.get(roomId || socket.data.roomId);
      const playerId = socket.data.playerId;
      if(!room) return cb && cb({ error: 'room not found' });
      if(!playerId) return cb && cb({ error: 'not joined' });
      // remove player immediately
      room.players = (room.players || []).filter(p => p.id !== playerId);
      // if the host left, promote the next player
      if(room.hostId && !room.players.find(p => p.id === room.hostId)){
        room.hostId = room.players[0] ? room.players[0].id : null;
      }
      // if fewer than 2 players remain, mark the room waiting
      if((room.players || []).length < 2 && room.status === 'playing') room.status = 'waiting';
      // leave socket.io room and clear socket data
      try{ socket.leave(room.id); }catch(_){ }
      try{ socket.data.roomId = null; }catch(_){ }
      // notify remaining players
      try{ sendRoomUpdate(room); }catch(_){ }
      return cb && cb({ ok: true });
    }catch(e){ console.error('room:leave error', e); return cb && cb({ error: 'server_error' }); }
  });

  // Host can toggle automatic drawing in the waiting room. Only the host may change this setting.
  socket.on('room:auto_draw:set', ({ roomId, enabled }, cb) => {
    const room = rooms.get(roomId);
    if(!room) return cb && cb({ error: 'room not found' });
    const sender = socket.data.playerId;
    if(!sender) return cb && cb({ error: 'not joined' });
    if(room.hostId !== sender) return cb && cb({ error: 'only the host can change auto-draw' });
    room.autoDraw = !!enabled;
    // Broadcast updated room state to all participants
    try{ sendRoomUpdate(room); }catch(_){ }
    try{ io.to(room.id).emit('room:auto_draw:changed', { roomId: room.id, enabled: room.autoDraw }); }catch(_){ }
    return cb && cb({ ok: true, autoDraw: room.autoDraw });
  });

  // Host can toggle the 'no remise' flag (prevent reshuffling discard into deck). Only the host may change this setting.
  socket.on('room:no_remise:set', ({ roomId, enabled }, cb) => {
    const room = rooms.get(roomId);
    if(!room) return cb && cb({ error: 'room not found' });
    const sender = socket.data.playerId;
    if(!sender) return cb && cb({ error: 'not joined' });
    if(room.hostId !== sender) return cb && cb({ error: 'only the host can change no-remise' });
    room.noRemise = !!enabled;
    // Broadcast updated room state to all participants
    try{ sendRoomUpdate(room); }catch(_){ }
    try{ io.to(room.id).emit('room:no_remise:changed', { roomId: room.id, enabled: room.noRemise }); }catch(_){ }
    return cb && cb({ ok: true, noRemise: room.noRemise });
  });

  socket.on('game:move', ({ roomId, from, to, promotion }, cb) => {
    const room = rooms.get(roomId);
    if (!room) return cb && cb({ error: 'room not found' });
    // don't allow moves in finished games
    if(room.status === 'finished') return cb && cb({ error: 'game_over' });
    // Basic move handling: validate turn, validate piece ownership, validate target is one of computeLegalMoves,
    // apply the move to room.boardState, handle captures, flip turn and broadcast the updated board.
    try{
      const senderId = socket.data.playerId;
      if(!senderId) return cb && cb({ error: 'not joined' });
      const roomPlayer = room.players.find(p => p.id === senderId);
      if(!roomPlayer) return cb && cb({ error: 'player not in room' });
      if(!room.boardState) return cb && cb({ error: 'no board state' });

      const board = room.boardState;
      // determine player's color short form ('w'|'b')
      const playerColorShort = (roomPlayer.color && roomPlayer.color[0]) || null;
      if(!playerColorShort) return cb && cb({ error: 'invalid player color' });

      // must be player's turn
      if(board.turn !== playerColorShort) return cb && cb({ error: 'not your turn' });

      // find piece at 'from'
      const pieces = board.pieces || [];
      const moving = pieces.find(p => p.square === from);
      if(!moving) return cb && cb({ error: 'no piece at source' });
      if(moving.color !== playerColorShort) return cb && cb({ error: 'not your piece' });

      // Enforce 'toucher' restriction: if there is an active 'toucher' effect targeting this player,
      // they may ONLY move the specified piece(s).
      try{
        const effects = room.activeCardEffects || [];
        const toucher = effects.find(e => e && e.type === 'toucher' && e.playerId === senderId);
        if(toucher && toucher.pieceId && moving.id !== toucher.pieceId){
          return cb && cb({ error: 'must_move_restricted_piece' });
        }
      }catch(_){ }

      // Enforce 'tout ou rien' restriction: if the moving piece is under 'tout_ou_rien', it may only move if the move captures
      try{
        const effects2 = room.activeCardEffects || [];
        const tout = effects2.find(e => e && e.type === 'tout_ou_rien' && e.pieceId === moving.id);
        if(tout){
          // only allow moves that capture an occupied square
          const targetIndexCheck = pieces.findIndex(p => p.square === to);
          if(targetIndexCheck === -1){
            return cb && cb({ error: 'must_capture_to_move' });
          }
        }
      }catch(_){ }

      // validate that 'to' is among legal moves
      const legal = computeLegalMoves(room, from) || [];
      const ok = legal.some(m => m.to === to);
      if(!ok) return cb && cb({ error: 'illegal move' });
      // additionally, do not allow moving into a fogged square if brouillard is active for this player
      try{
        const hasBrouillardForPlayer = (room.activeCardEffects || []).some(e => e.type === 'brouillard' && e.playerId === senderId);
        if(hasBrouillardForPlayer){
          const vis = visibleSquaresForPlayer(room, senderId);
          if(!vis.has(to)) return cb && cb({ error: 'destination not visible (fog of war)' });
        }
      }catch(e){ /* ignore */ }

      // apply move: remove any piece on target (capture)
      const targetIndex = pieces.findIndex(p => p.square === to);
      // sniper: special-case capture without moving when an active sniper effect is bound to the moving piece
      let sniperTriggered = false;
      if(targetIndex >= 0){
        // check for sniper effect bound to the moving piece for this player
        try{
          room.activeCardEffects = room.activeCardEffects || [];
          const sniperIdx = room.activeCardEffects.findIndex(e => e && e.type === 'sniper' && e.pieceId === moving.id && e.playerId === senderId);
          if(sniperIdx !== -1){
            // perform sniper capture: remove target piece and record it for potential resurrection
            const capturedPiece = pieces.splice(targetIndex, 1)[0];
            try{
              room.captured = room.captured || [];
              const originalOwner = (room.players || []).find(p => (p.color && p.color[0]) === capturedPiece.color);
              room.captured.push({ id: uuidv4().slice(0,8), piece: capturedPiece, originalOwnerId: (originalOwner && originalOwner.id) || null, capturedBy: senderId, ts: Date.now() });
              try{ if(capturedPiece && capturedPiece.invisible) delete capturedPiece.invisible; }catch(_){ }
            }catch(_){ /* ignore bookkeeping errors */ }
            // remove any invisible effects targeting the captured piece/square
            try{
              for(let ei = room.activeCardEffects.length - 1; ei >= 0; ei--){
                const ev = room.activeCardEffects[ei];
                if(!ev) continue;
                if(ev.type === 'invisible' && (ev.pieceId === capturedPiece.id || ev.pieceSquare === capturedPiece.square)){
                  try{ room.activeCardEffects.splice(ei,1); }catch(_){ }
                  try{ io.to(room.id).emit('card:effect:removed', { roomId: room.id, effectId: ev.id, type: ev.type, playerId: ev.playerId }); }catch(_){ }
                }
              }
            }catch(_){ }
            // consume the sniper effect (one-time)
            try{
              const removedEffect = room.activeCardEffects.splice(sniperIdx, 1)[0];
              try{ io.to(room.id).emit('card:effect:removed', { roomId: room.id, effectId: removedEffect && removedEffect.id, type: 'sniper', playerId: removedEffect && removedEffect.playerId }); }catch(_){ }
            }catch(_){ }
            sniperTriggered = true;
          } else {
            // no sniper: normal capture
            const capturedPiece = pieces.splice(targetIndex, 1)[0];
            try{
              room.captured = room.captured || [];
              const originalOwner = (room.players || []).find(p => (p.color && p.color[0]) === capturedPiece.color);
              room.captured.push({ id: uuidv4().slice(0,8), piece: capturedPiece, originalOwnerId: (originalOwner && originalOwner.id) || null, capturedBy: senderId, ts: Date.now() });
              try{ if(capturedPiece && capturedPiece.invisible) delete capturedPiece.invisible; }catch(_){ }
            }catch(_){ /* ignore bookkeeping errors */ }
            // If there were any 'invisible' effects targeting the captured piece or its square,
            // remove them so the square does not remain hidden for non-owners when another piece arrives.
            try{
              for(let ei = room.activeCardEffects.length - 1; ei >= 0; ei--){
                const ev = room.activeCardEffects[ei];
                if(!ev) continue;
                if(ev.type === 'invisible' && (ev.pieceId === capturedPiece.id || ev.pieceSquare === capturedPiece.square)){
                  try{ room.activeCardEffects.splice(ei,1); }catch(_){ }
                  try{ io.to(room.id).emit('card:effect:removed', { roomId: room.id, effectId: ev.id, type: ev.type, playerId: ev.playerId }); }catch(_){ }
                }
              }
            }catch(_){ }
          }
        }catch(_){
          // fallback: perform normal capture
          const capturedPiece = pieces.splice(targetIndex, 1)[0];
          try{ room.captured = room.captured || []; const originalOwner = (room.players || []).find(p => (p.color && p.color[0]) === capturedPiece.color); room.captured.push({ id: uuidv4().slice(0,8), piece: capturedPiece, originalOwnerId: (originalOwner && originalOwner.id) || null, capturedBy: senderId, ts: Date.now() }); }catch(_){ }
        }
      }
      // move the piece only if sniper didn't trigger
      if(!sniperTriggered){ moving.square = to; }

      // consume any active card effects bound to this piece (rebondir is one-time and should be removed)
      // also update any persistent effects (like adoubement) to track the piece's new square so they remain active
      try{
        room.activeCardEffects = room.activeCardEffects || [];
        // iterate backwards so we can splice safely
        for(let i = room.activeCardEffects.length - 1; i >= 0; i--){
          const e = room.activeCardEffects[i];
          // remove one-time rebondir if it refers to this piece (by pieceId or by its old square)
          if(e.type === 'rebondir' && (e.pieceSquare === from || (e.pieceId && e.pieceId === moving.id))){
            room.activeCardEffects.splice(i,1);
            continue;
          }
          // if the effect is bound to the piece id, update its recorded square so the effect persists after moves
          if(e.pieceId && e.pieceId === moving.id){
            e.pieceSquare = to;
          }
        }
      }catch(e){ console.error('consuming card effects error', e); }

      // Check for hidden mines at the destination square. If a mine belonging to another player
      // is present, detonate it: remove the moving piece and consume the mine. The mine location
      // is kept private (only the owner sees it in their `minesOwn`), but detonations are public.
      try{
        room.activeCardEffects = room.activeCardEffects || [];
        for(let i = room.activeCardEffects.length - 1; i >= 0; i--){
          const e = room.activeCardEffects[i];
          if(e && e.type === 'mine' && e.square === to){
            // detonate for any piece that lands on the mine (owner included)
            // remove the moving piece from the board and record it as captured by the mine owner
            const rmIdx = pieces.findIndex(p => p.id === moving.id);
            if(rmIdx >= 0){
              const capturedPiece = pieces.splice(rmIdx, 1)[0];
              try{
                room.captured = room.captured || [];
                const originalOwner = (room.players || []).find(p => (p.color && p.color[0]) === capturedPiece.color);
                room.captured.push({ id: uuidv4().slice(0,8), piece: capturedPiece, originalOwnerId: (originalOwner && originalOwner.id) || null, capturedBy: e.playerId, ts: Date.now() });
              }catch(_){ }
            }
            // consume the mine
            try{ room.activeCardEffects.splice(i,1); }catch(_){ }
            // broadcast detonation to the room (informational)
            try{ io.to(roomId).emit('mine:detonated', { roomId: room.id, ownerId: e.playerId, detonatorId: senderId, square: to, piece: moving }); }catch(_){ }
            // privately inform the owner as well with effect id and piece details
            try{ const owner = (room.players||[]).find(p => p.id === e.playerId); if(owner && owner.socketId) io.to(owner.socketId).emit('mine:detonated:private', { roomId: room.id, effectId: e.id, square: to, piece: moving }); }catch(_){ }
            // a mine was found/handled; break (only one mine per square expected)
            break;
          }
        }
      }catch(err){ console.error('mine detonation error', err); }

      // advance board version
      board.version = (board.version || 0) + 1;

      // Check victory (king capture) before further turn bookkeeping. If game ended, broadcast move and game:over and return.
      try{
        const end = checkAndHandleVictory(room);
        if(end && end.over){
          const moved = { playerId: senderId, from, to };
          try{ io.to(roomId).emit('move:moved', moved); }catch(_){ }
          // send personalized updates (room:update) so clients can refresh final board
          try{ sendRoomUpdate(room); }catch(_){ }
          return cb && cb({ ok: true, moved, gameOver: end });
        }
      }catch(_){ }

      // If the player was granted a free move by playing a card just now (room._freeMoveFor), consume it
      // and mark that we should end the turn after this move. We DO NOT treat it like a 'double_move' —
      // instead it is the player's one move for the turn and should cause normal end-of-turn bookkeeping.
      let consumedDoubleMove = false;
      let freeMoveConsumed = false;
      try{
        if(room && room._freeMoveFor && room._freeMoveFor === senderId){
          // consume the free-move token and remember to end the turn after this move
          freeMoveConsumed = true;
          try{ delete room._freeMoveFor; }catch(_){ room._freeMoveFor = null; }
          try{ io.to(room.id).emit('card:free_move_consumed', { roomId: room.id, playerId: senderId }); }catch(_){ }
        }
      }catch(e){ /* ignore */ }

      // Attempt to consume a double-move effect for the moving player. If present, this allows the player
      // to make an additional move without flipping the turn. We represent that effect as:
      // { type: 'double_move', playerId, remainingMoves }
      try{
        room.activeCardEffects = room.activeCardEffects || [];
        for(let i = room.activeCardEffects.length - 1; i >= 0; i--){
          const e = room.activeCardEffects[i];
          if(e.type === 'double_move' && e.playerId === senderId){
            // compute remaining moves after consuming one
            const newRemaining = (typeof e.remainingMoves === 'number') ? (e.remainingMoves - 1) : ((e.remainingMoves || 2) - 1);
            // update or remove depending on remaining count
            if(newRemaining > 0){
              e.remainingMoves = newRemaining;
              consumedDoubleMove = true; // still have extra moves, so don't flip the turn
              try{ io.to(room.id).emit('card:effect:updated', { roomId: room.id, effect: e }); }catch(_){ }
            } else {
              // used up: remove the effect and emit removal
              try{
                room.activeCardEffects.splice(i,1);
              }catch(_){ }
              try{ io.to(room.id).emit('card:effect:removed', { roomId: room.id, effectId: e.id, type: e.type, playerId: e.playerId }); }catch(_){ }
            }
            break;
          }
        }
      }catch(err){ console.error('double_move consume error', err); }

      // If the player didn't consume a double-move effect, flip turn and decrement per-turn effects
      if(!consumedDoubleMove){
        board.turn = (board.turn === 'w') ? 'b' : 'w';

        // decrement remainingTurns for any time-limited effects that belong to the player who just finished their turn
        try{
          room.activeCardEffects = room.activeCardEffects || [];
          for(let i = room.activeCardEffects.length - 1; i >= 0; i--){
            const e = room.activeCardEffects[i];
            if(typeof e.remainingTurns === 'number'){
              // determine whether this effect should be decremented when the player who just finished their turn is `senderId`.
              let shouldDecrement = false;
              if(e.decrementOn === 'opponent'){
                // decrement when the finished-turn player is NOT the effect owner
                shouldDecrement = (e.playerId !== senderId);
              } else if(e.decrementOn === 'owner'){
                // decrement only when the finished-turn player is the effect owner (legacy/default behavior)
                shouldDecrement = (e.playerId === senderId);
              } else {
                // default: existing semantics (decrement on the owner's turn)
                shouldDecrement = (e.playerId === senderId);
              }
              if(shouldDecrement){
                e.remainingTurns = e.remainingTurns - 1;
                // emit informative event when effect is decremented/removed
                try{ io.to(room.id).emit('card:effect:updated', { roomId: room.id, effect: e }); }catch(_){ }
                if(e.remainingTurns <= 0){
                  // remove expired effect
                  room.activeCardEffects.splice(i,1);
                  try{ io.to(room.id).emit('card:effect:removed', { roomId: room.id, effectId: e.id, type: e.type, playerId: e.playerId }); }catch(_){ }
                }
              }
            }
          }
        }catch(e){ console.error('updating temporary effects error', e); }

        // reset per-turn card-play flags because turn changed
        try{ room._cardPlayedThisTurn = {}; }catch(_){}
      }

      // at this point the board has been updated (and possibly the turn flipped)
      // determine next player and perform their draw BEFORE broadcasting the move, so the draw happens at the start of their turn
  const moved = { playerId: senderId, from, to };
      try{
          if(!consumedDoubleMove){
          const nextColor = board.turn; // 'w' or 'b'
          const nextPlayer = room.players.find(p => (p.color && p.color[0]) === nextColor);
          if(nextPlayer){
            // draw for next player (respect room.autoDraw)
            maybeDrawAtTurnStart(room, nextPlayer.id);
          } else {
            // ensure room state is broadcast
            sendRoomUpdate(room);
          }
        } else {
          // the same player still has an extra move; do not draw a new card now — just broadcast the updated room state
          sendRoomUpdate(room);
        }
      }catch(e){
        console.error('draw-at-start-of-turn error', e);
      }

      // now broadcast the move to all clients (move event separate from room:update)
    io.to(roomId).emit('move:moved', moved);

      return cb && cb({ ok: true, moved });
    }catch(err){
      console.error('game:move error', err);
      return cb && cb({ error: 'server error' });
    }
  });

  // Host can start the game explicitly
  socket.on('game:start', ({ roomId }, cb) => {
    const room = rooms.get(roomId);
    if (!room) return cb && cb({ error: 'room not found' });

    // verify sender is the host (first player)
    const senderId = socket.data.playerId;
    if (!senderId) return cb && cb({ error: 'not joined' });
    if (room.players.length < 2) return cb && cb({ error: 'need 2 players to start' });
    // verify sender is the host (explicit hostId)
    if (!room.hostId || room.hostId !== senderId) return cb && cb({ error: 'only host can start' });

  room.status = 'playing';
  // Do not broadcast the raw boardState to all sockets (use per-recipient sendRoomUpdate to enforce invisibility)
  io.to(roomId).emit('game:started', { roomId });
  sendRoomUpdate(room);

    // draw initial card for the player to move (beginning of their turn)
    // If the player already has a card (for instance the special starter card), skip the automatic draw
    try{
      if(room.boardState && room.boardState.turn){
        const firstColor = room.boardState.turn; // 'w' or 'b'
        const firstPlayer = room.players.find(p => (p.color && p.color[0]) === firstColor);
        if(firstPlayer){
          const hasHand = room.hands && room.hands[firstPlayer.id] && room.hands[firstPlayer.id].length > 0;
          if(!hasHand) maybeDrawAtTurnStart(room, firstPlayer.id);
        }
      }
    }catch(e){
      console.error('initial draw error', e);
    }

    cb && cb({ ok: true });
  });

  socket.on('disconnect', () => {
    const roomId = socket.data.roomId;
    if (!roomId) return;
    const room = rooms.get(roomId);
    if (!room) return;
    // delay removal to allow fast reconnects (e.g. navigation between pages)
    const playerId = socket.data.playerId;
    if(playerId && room.removalTimers){
      const t = setTimeout(()=>{
        room.players = room.players.filter(p => p.id !== playerId);
        // if the host left, promote the next player to host (or null)
        if (room.hostId && !room.players.find(p => p.id === room.hostId)) {
          room.hostId = room.players[0] ? room.players[0].id : null;
        }
        if (room.players.length < 2 && room.status === 'playing') room.status = 'waiting';
        sendRoomUpdate(room);
        room.removalTimers.delete(playerId);
      }, 5000);
      room.removalTimers.set(playerId, t);
    } else {
      // fallback: immediate removal
      room.players = room.players.filter(p => p.socketId !== socket.id);
      if (room.players.length < 2 && room.status === 'playing') room.status = 'waiting';
      if (room.hostId && !room.players.find(p => p.id === room.hostId)) {
        room.hostId = room.players[0] ? room.players[0].id : null;
      }
      sendRoomUpdate(room);
    }
  });

  // delegates to `computeLegalMoves` which is a stub you should implement.
  // legalMoves API removed (movement UI disabled)
  // Re-add legalMoves API to compute and return pseudo-legal moves for a square.
  socket.on('game:legalMoves', ({ roomId, square }, cb) => {
    const room = rooms.get(roomId);
    if (!room) return cb && cb({ error: 'room not found' });
    try{
      const moves = computeLegalMoves(room, square) || [];
      return cb && cb({ ok: true, moves });
    }catch(e){
      console.error('game:legalMoves error', e);
      return cb && cb({ error: 'invalid square', moves: [] });
    }
  });

  // propagate selection made by one client to the other clients in the same room
  socket.on('game:select', ({ roomId, square }, cb) => {
    const room = rooms.get(roomId);
    if(!room) return cb && cb({ error: 'room not found' });
    const playerId = socket.data.playerId || null;
    // remember last selected square for this socket so cards that need a target can use it
    try{ socket.data.lastSelectedSquare = square || null; }catch(e){}
    // compute legal moves for the selected square (allow capturing king)
    let moves = [];
    try{
      if(square) moves = computeLegalMoves(room, square) || [];
    }catch(e){
      console.error('computeLegalMoves error', e);
      moves = [];
    }
    // Enforce 'toucher' restriction: if the selecting player is affected by a 'toucher' effect,
    // they may only move the targeted piece. If they select another piece, show no moves.
    try{
      const effects = room.activeCardEffects || [];
      const toucherEffects = effects.filter(e => e && e.type === 'toucher' && e.playerId === playerId);
      if(toucherEffects && toucherEffects.length > 0){
        const selectedPiece = (room.boardState && room.boardState.pieces || []).find(p => p.square === square);
        const allowedPieceIds = toucherEffects.map(e => e.pieceId).filter(Boolean);
        if(!selectedPiece || allowedPieceIds.indexOf(selectedPiece.id) === -1){
          moves = [];
        }
      }
    }catch(_){ /* ignore enforcement errors */ }
    // send selection to the selecting client WITH moves, but broadcast selection WITHOUT moves to other clients
    try{
      // send to selecting socket (include moves)
      socket.emit('game:select', { playerId, square, moves });
      // (pending-target flow removed) — server no longer auto-applies pending card targets on selection
      // notify other sockets in the room about the selection but without revealing the legal moves
      socket.to(roomId).emit('game:select', { playerId, square, moves: [] });
    }catch(e){
      // fallback: broadcast to all (shouldn't normally happen)
      io.to(roomId).emit('game:select', { playerId, square, moves: [] });
    }
    cb && cb({ ok: true });
  });

  // Manual draw by player (consumes the player's turn). Only valid when autoDraw is disabled.
  socket.on('player:draw', ({ roomId }, cb) => {
    const room = rooms.get(roomId);
    if(!room) return cb && cb({ error: 'room not found' });
    if(room.status === 'finished') return cb && cb({ error: 'game_over' });
    const senderId = socket.data.playerId;
    if(!senderId) return cb && cb({ error: 'not joined' });
    const board = room.boardState;
    if(!board) return cb && cb({ error: 'no board state' });
    const roomPlayer = room.players.find(p => p.id === senderId);
    if(!roomPlayer) return cb && cb({ error: 'player not in room' });
    const playerColorShort = (roomPlayer.color && roomPlayer.color[0]) || null;
    // must be player's turn
    if(board.turn !== playerColorShort) return cb && cb({ error: 'not your turn' });
    // manual draw only allowed when autoDraw is disabled
    if(room.autoDraw) return cb && cb({ error: 'auto_draw_enabled' });
    // do not allow drawing if player already played a card this turn
    room._cardPlayedThisTurn = room._cardPlayedThisTurn || {};
    if(room._cardPlayedThisTurn[senderId]) return cb && cb({ error: 'card_already_played_this_turn' });

    try{
      // perform the draw (this will emit card:drawn privately and send personalized room:update)
      const drawn = drawCardForPlayer(room, senderId);
      if(!drawn){
        // nothing drawn (hand full or deck empty)
        return cb && cb({ error: 'no_card_drawn' });
      }
      // drawing consumes the player's turn: flip turn and decrement per-turn effects
      // advance board version
      board.version = (board.version || 0) + 1;

      // If the move consumed a free-move granted by a card, perform end-of-turn bookkeeping now
      if(freeMoveConsumed){
        const moved = { playerId: senderId, from, to };
        try{ io.to(roomId).emit('move:moved', moved); }catch(_){ }
        try{ endTurnAfterCard(room, senderId); }catch(e){ try{ sendRoomUpdate(room); }catch(_){ } }
        return cb && cb({ ok: true, moved });
      }
      // flip turn
      board.turn = (board.turn === 'w') ? 'b' : 'w';
      // decrement remainingTurns for time-limited effects that belong to the player who just finished their turn
      try{
        room.activeCardEffects = room.activeCardEffects || [];
        for(let i = room.activeCardEffects.length - 1; i >= 0; i--){
          const e = room.activeCardEffects[i];
          if(typeof e.remainingTurns === 'number'){
            let shouldDecrement = false;
            if(e.decrementOn === 'opponent'){
              shouldDecrement = (e.playerId !== senderId);
            } else if(e.decrementOn === 'owner'){
              shouldDecrement = (e.playerId === senderId);
            } else {
              shouldDecrement = (e.playerId === senderId);
            }
            if(shouldDecrement){
              e.remainingTurns = e.remainingTurns - 1;
              try{ io.to(room.id).emit('card:effect:updated', { roomId: room.id, effect: e }); }catch(_){ }
              if(e.remainingTurns <= 0){ room.activeCardEffects.splice(i,1); try{ io.to(room.id).emit('card:effect:removed', { roomId: room.id, effectId: e.id, type: e.type, playerId: e.playerId }); }catch(_){ } }
            }
          }
        }
      }catch(e){ console.error('decrement-after-draw error', e); }

      // reset per-turn card-play flags
      try{ room._cardPlayedThisTurn = {}; }catch(_){ }

      // at this point it's the next player's turn; perform start-of-turn draw if autoDraw enabled
      const nextColor = board.turn;
      const nextPlayer = (room.players || []).find(p => (p.color && p.color[0]) === nextColor);
      if(nextPlayer){ try{ maybeDrawAtTurnStart(room, nextPlayer.id); }catch(_){ sendRoomUpdate(room); } }
      else { sendRoomUpdate(room); }

      // notify room that the player drew and ended their turn
      try{ io.to(room.id).emit('player:drew', { roomId: room.id, playerId: senderId, card: drawn }); }catch(_){ }
      return cb && cb({ ok: true, card: drawn });
    }catch(err){ console.error('player:draw error', err); return cb && cb({ error: 'server_error' }); }
  });

  // Simple cards API via sockets: list/play
  socket.on('card:list', ({ roomId }, cb) => {
    const room = rooms.get(roomId);
    if(!room) return cb && cb({ error: 'room not found' });
    // return available card types (placeholder)
    const available = [
      { id: 'invert', name: 'Invert Turn', description: 'Swap movement directions for one move' },
      { id: 'teleport', name: 'Teleport', description: 'Move one piece to any empty square' }
    ];
    cb && cb({ ok: true, cards: available });
  });

  socket.on('card:play', ({ roomId, playerId, cardId, payload }, cb) => {
    const room = rooms.get(roomId);
    if(!room) return cb && cb({ error: 'room not found' });
    if(room.status === 'finished') return cb && cb({ error: 'game_over' });
    // enforce sender identity from socket (don't trust client-supplied playerId)
    const senderId = socket.data.playerId;
    if(!senderId) return cb && cb({ error: 'not joined' });
    // enforce one card per player per turn when the game is playing
    try{
      const board = room.boardState;
      if(room.status === 'playing' && board){
        const roomPlayer = room.players.find(p => p.id === senderId);
        const playerColorShort = (roomPlayer && roomPlayer.color && roomPlayer.color[0]) || null;
        // only allow playing a card on your turn
        if(board.turn !== playerColorShort) return cb && cb({ error: 'not your turn' });
        // track card plays per turn (not per board version) so effects like "double move" don't allow extra card plays
        room._cardPlayedThisTurn = room._cardPlayedThisTurn || {};
        if(room._cardPlayedThisTurn[senderId]) return cb && cb({ error: 'card_already_played_this_turn' });
      }
    }catch(e){ console.error('card play pre-check error', e); }
    // store played card and apply card effects when applicable
    const played = { id: uuidv4().slice(0,8), playerId: senderId, cardId, payload, ts: Date.now() };
    room.playedCards = room.playedCards || [];

    // Pre-check for targetted cards (rebondir, adoubement, folie, fortification): require a selected target owned by the player
    try{
      const isRebond = (typeof cardId === 'string') && (cardId.indexOf('rebondir') !== -1 || cardId.indexOf('rebond') !== -1);
      const isAdoub = (typeof cardId === 'string') && (cardId.indexOf('adoub') !== -1 || cardId.indexOf('adoubement') !== -1);
      const isFolie = (typeof cardId === 'string') && (cardId.indexOf('folie') !== -1 || cardId.indexOf('fou') !== -1);
      const isFort = (typeof cardId === 'string') && (cardId.indexOf('fortification') !== -1 || cardId.indexOf('fortif') !== -1);
      const isTargetCard = isRebond || isAdoub || isFolie || isFort;
      if(isTargetCard){
        const board = room.boardState;
        let targetCandidate = payload && payload.targetSquare;
        if(!targetCandidate){ try{ targetCandidate = socket.data && socket.data.lastSelectedSquare; }catch(e){ targetCandidate = null; } }
        const roomPlayer = room.players.find(p => p.id === senderId);
        const playerColorShort = (roomPlayer && roomPlayer.color && roomPlayer.color[0]) || null;
        const targetPiece = (board && board.pieces || []).find(p => p.square === targetCandidate);
        if(!board || !targetCandidate || !targetPiece || targetPiece.color !== playerColorShort){
          // nothing should happen if there's no selected piece or the selected piece isn't owned by the player
          return cb && cb({ error: 'no valid target' });
        }
        // ensure the payload has the resolved target for downstream handling
        payload = payload || {};
        payload.targetSquare = targetCandidate;
        played.payload = Object.assign({}, payload);
      }
    }catch(e){ console.error('target card pre-check error', e); }

    // remove the played card from the player's hand and move it to discard
    try{
      room.hands = room.hands || {};
      const hand = room.hands[senderId] || [];
      // find by unique id or by cardId (first match)
      const idx = hand.findIndex(c => (c.id && c.id === (payload && payload.id)) || (c.cardId && c.cardId === cardId) || (c.id && c.id === cardId));
      if(idx === -1){
        return cb && cb({ error: 'you do not have that card' });
      }
      const removed = hand.splice(idx,1)[0];
      room.hands[senderId] = hand;
      room.discard = room.discard || [];
      // Respect the room.noRemise flag: when true, do NOT move the played card into the discard pile.
      if(!room.noRemise){
        room.discard.push(removed);
        // attach the removed card object to the played record for informational broadcast
        played.card = removed;
        played._discarded = true;
      } else {
        // still attach the card instance for informational purposes but note it wasn't discarded
        played.card = removed;
        played._discarded = false;
      }
  // normalize cardId to the card's slug when the client passed an instance id
  cardId = (removed && removed.cardId) || cardId;
    }catch(e){
      console.error('card removal error', e);
    }

  // Implement specific card effects here
  // Convention: For cards that require a target, if the target is invalid the card is consumed by default
  // (player loses the card). If you want a different behavior for a specific card, explicitly restore
  // the removed card to the player's hand in that branch. This keeps UX consistent across cards.
    try{
  if(cardId === 'agrandir_plateau' || cardId === 'expand_board' || (typeof cardId === 'string' && cardId.indexOf('agrandir') !== -1)){
        // Expand the board by adding one file/column on the left and right and one rank on top and bottom.
        const board = room.boardState;
        if(board && board.width && board.height){
          const oldW = board.width;
          const oldH = board.height;
          const newW = oldW + 2;
          const newH = oldH + 2;

          // helper: parse square -> coords (0-indexed)
          function squareToCoord(sq){
            if(!sq) return null;
            const s = String(sq).trim().toLowerCase();
            if(!/^[a-z][1-9][0-9]*$/.test(s)) return null;
            const file = s.charCodeAt(0) - 'a'.charCodeAt(0);
            const rank = parseInt(s.slice(1),10) - 1;
            return { x: file, y: rank };
          }
          function coordToSquare(x,y){
            return String.fromCharCode('a'.charCodeAt(0) + x) + (y+1);
          }

          // shift every piece by +1 file and +1 rank
          (board.pieces || []).forEach(p => {
            const c = squareToCoord(p.square);
            if(!c) return;
            const nx = c.x + 1;
            const ny = c.y + 1;
            p.square = coordToSquare(nx, ny);
          });

          board.width = newW;
          board.height = newH;
          board.version = (board.version || 0) + 1;

          // record effect details on payload for clients
          played.payload = Object.assign({}, payload, { applied: 'agrandir_plateau', oldWidth: oldW, oldHeight: oldH, newWidth: newW, newHeight: newH });
        }
      } else if(cardId === 'tronquer_plateau' || cardId === 'tronquer_le_plateau' || (typeof cardId === 'string' && cardId.indexOf('tronquer') !== -1)){
        // Tronquer (trim) is currently disabled: record the play but do not modify the board.
        // Historically this code computed the occupied bounding box and rewrote board.pieces/width/height.
        // That behavior caused unintended piece removals in some edge cases, so trimming is commented out for now.
        played.payload = Object.assign({}, payload, { applied: 'tronquer_plateau', note: 'disabled - trimming commented out by developer' });
      }
      // adoubement: grant a permanent knight-move ability to the targeted piece
      else if(cardId === 'adoubement' || (typeof cardId === 'string' && cardId.indexOf('adoub') !== -1)){
        try{
          const board = room.boardState;
          let target = payload && payload.targetSquare;
          if(!target){ try{ target = socket.data && socket.data.lastSelectedSquare; }catch(e){ target = null; } }
          // validate target exists and belongs to the player
          const roomPlayer = room.players.find(p => p.id === senderId);
          const playerColorShort = (roomPlayer && roomPlayer.color && roomPlayer.color[0]) || null;
          const targetPiece = (board && board.pieces || []).find(p => p.square === target);
          if(!board || !target || !targetPiece || targetPiece.color !== playerColorShort){
            // restore removed card to hand and remove from discard if necessary
            try{
              room.hands = room.hands || {};
              room.hands[senderId] = room.hands[senderId] || [];
              if(removed) room.hands[senderId].push(removed);
              room.discard = room.discard || [];
              for(let i = room.discard.length - 1; i >= 0; i--){ if(room.discard[i] && room.discard[i].id === (removed && removed.id)){ room.discard.splice(i,1); break; } }
            }catch(e){ console.error('restore removed card error', e); }
            return cb && cb({ error: 'no valid target' });
          }
          // apply permanent adoubement effect (bind to piece id so it persists when the piece moves)
          room.activeCardEffects = room.activeCardEffects || [];
          room.activeCardEffects.push({ id: played.id, type: 'adoubement', pieceId: targetPiece.id, pieceSquare: target, playerId: senderId });
          played.payload = Object.assign({}, payload, { applied: 'adoubement', appliedTo: target });
        }catch(e){ console.error('adoubement effect error', e); }
          }
          // folie: grant permanent bishop-move ability to the targeted piece
          else if(cardId === 'folie' || (typeof cardId === 'string' && cardId.indexOf('folie') !== -1)){
            try{
              const board = room.boardState;
              let target = payload && payload.targetSquare;
              if(!target){ try{ target = socket.data && socket.data.lastSelectedSquare; }catch(e){ target = null; } }
              // validate target exists and belongs to the player
              const roomPlayer = room.players.find(p => p.id === senderId);
              const playerColorShort = (roomPlayer && roomPlayer.color && roomPlayer.color[0]) || null;
              const targetPiece = (board && board.pieces || []).find(p => p.square === target);
              if(!board || !target || !targetPiece || targetPiece.color !== playerColorShort){
                // restore removed card to hand and remove from discard if necessary
                try{
                  room.hands = room.hands || {};
                  room.hands[senderId] = room.hands[senderId] || [];
                  if(removed) room.hands[senderId].push(removed);
                  room.discard = room.discard || [];
                  for(let i = room.discard.length - 1; i >= 0; i--){ if(room.discard[i] && room.discard[i].id === (removed && removed.id)){ room.discard.splice(i,1); break; } }
                }catch(e){ console.error('restore removed card error', e); }
                return cb && cb({ error: 'no valid target' });
              }
              // apply permanent folie effect (bind to piece id so it persists when the piece moves)
              room.activeCardEffects = room.activeCardEffects || [];
              room.activeCardEffects.push({ id: played.id, type: 'folie', pieceId: targetPiece.id, pieceSquare: target, playerId: senderId });
              played.payload = Object.assign({}, payload, { applied: 'folie', appliedTo: target });
            }catch(e){ console.error('folie effect error', e); }
      }
      // fortification: grant permanent rook-move ability to the targeted piece
      else if(cardId === 'fortification' || (typeof cardId === 'string' && cardId.indexOf('fortification') !== -1)){
        try{
          const board = room.boardState;
          let target = payload && payload.targetSquare;
          if(!target){ try{ target = socket.data && socket.data.lastSelectedSquare; }catch(e){ target = null; } }
          // validate target exists and belongs to the player
          const roomPlayer = room.players.find(p => p.id === senderId);
          const playerColorShort = (roomPlayer && roomPlayer.color && roomPlayer.color[0]) || null;
          const targetPiece = (board && board.pieces || []).find(p => p.square === target);
          if(!board || !target || !targetPiece || targetPiece.color !== playerColorShort){
            // restore removed card to hand and remove from discard if necessary
            try{
              room.hands = room.hands || {};
              room.hands[senderId] = room.hands[senderId] || [];
              if(removed) room.hands[senderId].push(removed);
              room.discard = room.discard || [];
              for(let i = room.discard.length - 1; i >= 0; i--){ if(room.discard[i] && room.discard[i].id === (removed && removed.id)){ room.discard.splice(i,1); break; } }
            }catch(e){ console.error('restore removed card error', e); }
            return cb && cb({ error: 'no valid target' });
          }
          // apply permanent fortification effect (bind to piece id so it persists when the piece moves)
          room.activeCardEffects = room.activeCardEffects || [];
          room.activeCardEffects.push({ id: played.id, type: 'fortification', pieceId: targetPiece.id, pieceSquare: target, playerId: senderId });
          played.payload = Object.assign({}, payload, { applied: 'fortification', appliedTo: target });
        }catch(e){ console.error('fortification effect error', e); }
      }
      // toucher c'est jouer: force the targeted player to move only the chosen piece on their next turn
      else if((typeof cardId === 'string' && cardId.indexOf('toucher') !== -1) || cardId === 'toucher_cest_jouer'){
        try{
          const board = room.boardState;
          let target = payload && payload.targetSquare;
          if(!target){ try{ target = socket.data && socket.data.lastSelectedSquare; }catch(e){ target = null; } }
          const roomPlayer = room.players.find(p => p.id === senderId);
          const playerColorShort = (roomPlayer && roomPlayer.color && roomPlayer.color[0]) || null;
          const targetPiece = (board && board.pieces || []).find(p => p.square === target);
          // validate target exists and belongs to the opponent
          if(!board || !target || !targetPiece || targetPiece.color === playerColorShort){
            // invalid target: restore removed card to hand and abort
            try{
              room.hands = room.hands || {};
              room.hands[senderId] = room.hands[senderId] || [];
              if(removed) room.hands[senderId].push(removed);
              room.discard = room.discard || [];
              for(let i = room.discard.length - 1; i >= 0; i--){ if(room.discard[i] && room.discard[i].id === (removed && removed.id)){ room.discard.splice(i,1); break; } }
            }catch(e){ console.error('restore removed card error', e); }
            return cb && cb({ error: 'no valid target' });
          }
          // find the owner (player) of the targeted piece
          const targetOwner = (room.players || []).find(p => (p.color && p.color[0]) === targetPiece.color) || null;
          // create a one-turn effect that forces the targetOwner to move only this piece on their next turn
          room.activeCardEffects = room.activeCardEffects || [];
          const effect = { id: played.id, type: 'toucher', playerId: (targetOwner && targetOwner.id) || null, pieceId: targetPiece.id, pieceSquare: targetPiece.square, remainingTurns: 1, decrementOn: 'owner', imposedBy: senderId, ts: Date.now() };
          room.activeCardEffects.push(effect);
          played.payload = Object.assign({}, payload, { applied: 'toucher', appliedTo: target });
          try{ io.to(room.id).emit('card:effect:applied', { roomId: room.id, effect }); }catch(_){ }
        }catch(e){ console.error('toucher effect error', e); }
        }
        // la parrure: downgrade an enemy queen to a pawn (selected target must be an enemy queen)
        else if((typeof cardId === 'string' && cardId.indexOf('parrure') !== -1) || cardId === 'la_parrure'){
          try{
            const board = room.boardState;
            let target = payload && payload.targetSquare;
            if(!target){ try{ target = socket.data && socket.data.lastSelectedSquare; }catch(e){ target = null; } }
            const roomPlayer = room.players.find(p => p.id === senderId);
            const playerColorShort = (roomPlayer && roomPlayer.color && roomPlayer.color[0]) || null;
            const targetPiece = (board && board.pieces || []).find(p => p.square === target);
            // validate target exists and belongs to the opponent and is a queen
            if(!board || !target || !targetPiece || targetPiece.color === playerColorShort || !targetPiece.type || targetPiece.type.toLowerCase() !== 'q'){
              // invalid target: do NOT restore the removed card (card is consumed). Return error but card remains in discard.
              return cb && cb({ error: 'no valid target' });
            }
            // perform downgrade: change piece type to pawn
            try{
              targetPiece.type = 'p';
              if(targetPiece.promoted) delete targetPiece.promoted;
              // bump board version so clients react to the board mutation
              try{ board.version = (board.version || 0) + 1; }catch(_){ }
              played.payload = Object.assign({}, payload, { applied: 'parrure', appliedTo: target });
              try{ io.to(room.id).emit('card:effect:applied', { roomId: room.id, effect: { id: played.id, type: 'parrure', pieceId: targetPiece.id, pieceSquare: targetPiece.square, playerId: senderId } }); }catch(_){ }
            }catch(e){ console.error('parrure apply error', e); }
          }catch(e){ console.error('parrure effect error', e); }
        }
        // sniper: bind a one-time sniper effect to one of your pieces.
        // After playing this card the owner selects one of their pieces; the effect is recorded and
        // when that piece later makes a capturing move, the capture is performed without moving the capturer.
        else if((typeof cardId === 'string' && cardId.indexOf('sniper') !== -1) || cardId === 'sniper'){
          try{
            const board = room.boardState;
            // client may send selected piece in payload.targetSquare (legacy owned selection) or payload.sourceSquare
            let source = (payload && payload.sourceSquare) || (payload && payload.targetSquare) || null;
            if(!source){ try{ source = socket.data && socket.data.lastSelectedSquare; }catch(e){ source = null; } }
            const roomPlayer = room.players.find(p => p.id === senderId);
            const playerColorShort = (roomPlayer && roomPlayer.color && roomPlayer.color[0]) || null;
            const srcPiece = (board && board.pieces || []).find(p => p.square === source);
            if(!board || !source || !srcPiece || srcPiece.color !== playerColorShort){
              // invalid target: restore card to hand and abort
              try{
                room.hands = room.hands || {};
                room.hands[senderId] = room.hands[senderId] || [];
                if(removed) room.hands[senderId].push(removed);
                room.discard = room.discard || [];
                for(let i = room.discard.length - 1; i >= 0; i--){ if(room.discard[i] && room.discard[i].id === (removed && removed.id)){ room.discard.splice(i,1); break; } }
              }catch(_){ }
              return cb && cb({ error: 'no valid source selected' });
            }
            // bind sniper effect to the piece id (one-time use)
            room.activeCardEffects = room.activeCardEffects || [];
            const effect = { id: played.id, type: 'sniper', playerId: senderId, pieceId: srcPiece.id, pieceSquare: srcPiece.square, remainingUses: 1, imposedBy: senderId, ts: Date.now() };
            room.activeCardEffects.push(effect);
            played.payload = Object.assign({}, payload, { applied: 'sniper_bound', appliedTo: source });
            try{ io.to(room.id).emit('card:effect:applied', { roomId: room.id, effect }); }catch(_){ }
          }catch(e){ console.error('sniper binding error', e); }
        }
        // tout ou rien: choose a piece; that piece may only move if it captures (one owner turn)
        else if((typeof cardId === 'string' && cardId.indexOf('tout') !== -1 && cardId.indexOf('rien') !== -1) || cardId === 'tout_ou_rien'){
          try{
            const board = room.boardState;
            let target = payload && payload.targetSquare;
            if(!target){ try{ target = socket.data && socket.data.lastSelectedSquare; }catch(e){ target = null; } }
            const targetPiece = (board && board.pieces || []).find(p => p.square === target);
            if(!board || !target || !targetPiece){
              // invalid target: do not restore card (consume) and return error
              return cb && cb({ error: 'no valid target' });
            }
            // do not allow kings to be affected
            if(targetPiece.type && targetPiece.type.toLowerCase() === 'k'){
              // consume card but report invalid
              return cb && cb({ error: 'cannot_target_king' });
            }
            // find owner of the targeted piece
            const targetOwner = (room.players || []).find(p => (p.color && p.color[0]) === targetPiece.color) || null;
            room.activeCardEffects = room.activeCardEffects || [];
            // Make 'tout_ou_rien' permanent until explicitly removed by another effect
            const effect = { id: played.id, type: 'tout_ou_rien', playerId: (targetOwner && targetOwner.id) || null, pieceId: targetPiece.id, pieceSquare: targetPiece.square, imposedBy: senderId, ts: Date.now() };
            room.activeCardEffects.push(effect);
            played.payload = Object.assign({}, payload, { applied: 'tout_ou_rien', appliedTo: target });
            try{ io.to(room.id).emit('card:effect:applied', { roomId: room.id, effect }); }catch(_){ }
          }catch(e){ console.error('tout_ou_rien effect error', e); }
        }
        // inversion: pick one of your pieces, then pick an enemy piece — swap their squares
        else if((typeof cardId === 'string' && cardId.indexOf('inversion') !== -1) || cardId === 'inversion'){
          try{
            const board = room.boardState;
            const payloadSrc = payload && payload.sourceSquare;
            const payloadTgt = payload && payload.targetSquare;
            // fallback to lastSelectedSquare for source if client didn't provide both
            let source = payloadSrc || null;
            let target = payloadTgt || null;
            if(!source){ try{ source = socket.data && socket.data.lastSelectedSquare; }catch(_){ source = null; } }
            if(!target){ /* nothing */ }
            const roomPlayer = room.players.find(p => p.id === senderId);
            const playerColorShort = (roomPlayer && roomPlayer.color && roomPlayer.color[0]) || null;
            const srcPiece = (board && board.pieces || []).find(p => p.square === source);
            const tgtPiece = (board && board.pieces || []).find(p => p.square === target);
            // validate both pieces exist and belong respectively to player and opponent
            if(!board || !source || !target || !srcPiece || !tgtPiece || srcPiece.color !== playerColorShort || tgtPiece.color === playerColorShort){
              // invalid target(s): restore removed card to hand and abort
              try{ room.hands = room.hands || {}; room.hands[senderId] = room.hands[senderId] || []; if(removed) room.hands[senderId].push(removed); room.discard = room.discard || []; for(let i = room.discard.length - 1; i >= 0; i--){ if(room.discard[i] && room.discard[i].id === (removed && removed.id)){ room.discard.splice(i,1); break; } } }catch(e){ console.error('restore removed card error', e); }
              return cb && cb({ error: 'no valid targets' });
            }
            // swap their squares
            try{
              const sSquare = srcPiece.square;
              const tSquare = tgtPiece.square;
              srcPiece.square = tSquare;
              tgtPiece.square = sSquare;
              // update any activeCardEffects that reference squares
              try{
                room.activeCardEffects = room.activeCardEffects || [];
                room.activeCardEffects.forEach(e => {
                  try{
                    if(e && e.pieceSquare && e.pieceSquare === sSquare) e.pieceSquare = tSquare;
                    else if(e && e.pieceSquare && e.pieceSquare === tSquare) e.pieceSquare = sSquare;
                  }catch(_){ }
                });
              }catch(_){ }
              // bump board version
              try{ board.version = (board.version || 0) + 1; }catch(_){ }
              played.payload = Object.assign({}, payload, { applied: 'inversion', from: source, to: target });
              try{ io.to(room.id).emit('card:effect:applied', { roomId: room.id, effect: { id: played.id, type: 'inversion', swapped: [srcPiece.id, tgtPiece.id], playerId: senderId } }); }catch(_){ }
            }catch(e){ console.error('inversion apply error', e); }
          }catch(e){ console.error('inversion effect error', e); }
      }
      // teleportation: allow the selected piece to move to any empty square for one turn
      else if((typeof cardId === 'string' && (cardId.indexOf('teleport') !== -1 || cardId.indexOf('t_l_portation') !== -1 || cardId.indexOf('t_lportation') !== -1)) || cardId === 'teleport'){
        try{
          const board = room.boardState;
          let target = payload && payload.targetSquare;
          if(!target){ try{ target = socket.data && socket.data.lastSelectedSquare; }catch(e){ target = null; } }
          // validate target exists and belongs to the player
          const roomPlayer = room.players.find(p => p.id === senderId);
          const playerColorShort = (roomPlayer && roomPlayer.color && roomPlayer.color[0]) || null;
          const targetPiece = (board && board.pieces || []).find(p => p.square === target);
          if(!board || !target || !targetPiece || targetPiece.color !== playerColorShort){
            // restore removed card to hand and remove from discard if necessary
            try{
              room.hands = room.hands || {};
              room.hands[senderId] = room.hands[senderId] || [];
              if(removed) room.hands[senderId].push(removed);
              room.discard = room.discard || [];
              for(let i = room.discard.length - 1; i >= 0; i--){ if(room.discard[i] && room.discard[i].id === (removed && removed.id)){ room.discard.splice(i,1); break; } }
            }catch(e){ console.error('restore removed card error', e); }
            return cb && cb({ error: 'no valid target' });
          }
          // apply a temporary teleport effect bound to the piece id for one owner turn
          room.activeCardEffects = room.activeCardEffects || [];
          const effect = { id: played.id, type: 'teleport', pieceId: targetPiece.id, pieceSquare: target, playerId: senderId, remainingTurns: 1, decrementOn: 'owner' };
          room.activeCardEffects.push(effect);
          played.payload = Object.assign({}, payload, { applied: 'teleport', appliedTo: target });
          try{ io.to(room.id).emit('card:effect:applied', { roomId: room.id, effect }); }catch(_){ }
        }catch(e){ console.error('teleport effect error', e); }
        }
      // changement de camp / flip sides: swap the camps so each player controls the other's pieces
      else if((typeof cardId === 'string' && (cardId.indexOf('changement') !== -1 || cardId.indexOf('changer') !== -1 || cardId.indexOf('change') !== -1 || cardId.indexOf('camp') !== -1)) || cardId === 'changement_de_camp'){
        try{
          const board = room.boardState;
          if(!board || !Array.isArray(board.pieces)){
            // nothing to do; restore card
            try{
              room.hands = room.hands || {};
              room.hands[senderId] = room.hands[senderId] || [];
              if(removed) room.hands[senderId].push(removed);
              room.discard = room.discard || [];
              for(let i = room.discard.length - 1; i >= 0; i--){ if(room.discard[i] && room.discard[i].id === (removed && removed.id)){ room.discard.splice(i,1); break; } }
            }catch(e){ }
            return cb && cb({ error: 'no board to flip' });
          }
          // swap piece colors
          // helper: square <-> coords
          function squareToCoord(sq){ if(!sq) return null; const s = String(sq).trim().toLowerCase(); if(!/^[a-z][1-9][0-9]*$/.test(s)) return null; const file = s.charCodeAt(0) - 'a'.charCodeAt(0); const rank = parseInt(s.slice(1),10) - 1; return { x: file, y: rank }; }
          function coordToSquare(x,y){ if(x<0||y<0||!board.width||!board.height) return null; if(x<0||y<0||x>=board.width||y>=board.height) return null; return String.fromCharCode('a'.charCodeAt(0) + x) + (y+1); }
          // perform 180° rotation and swap piece colors
          const w = board.width || 8; const h = board.height || 8;
          (board.pieces || []).forEach(p => {
            try{
              // rotate square
              const c = squareToCoord(p.square);
              if(c){ const nx = (w - 1) - c.x; const ny = (h - 1) - c.y; const ns = coordToSquare(nx, ny); if(ns) p.square = ns; }
              // swap colour
              p.color = (p.color === 'w' ? 'b' : (p.color === 'b' ? 'w' : p.color));
            }catch(_){ }
          });
          // also rotate/adjust any active effect squares (pieceSquare, square, allowedSquares)
          try{
            room.activeCardEffects = room.activeCardEffects || [];
            room.activeCardEffects.forEach(e => {
              if(!e) return;
              try{
                if(e.pieceSquare){ const c = squareToCoord(e.pieceSquare); if(c){ const nx = (w-1)-c.x; const ny = (h-1)-c.y; const ns = coordToSquare(nx,ny); if(ns) e.pieceSquare = ns; } }
                if(e.square){ const c2 = squareToCoord(e.square); if(c2){ const nx = (w-1)-c2.x; const ny = (h-1)-c2.y; const ns2 = coordToSquare(nx,ny); if(ns2) e.square = ns2; } }
                if(Array.isArray(e.allowedSquares)){
                  e.allowedSquares = e.allowedSquares.map(sq => { const cc = squareToCoord(sq); if(!cc) return sq; const nx = (w-1)-cc.x; const ny = (h-1)-cc.y; return coordToSquare(nx,ny) || sq; });
                }
              }catch(_){ }
            });
          }catch(_){ }
          // swap players' assigned colors (so UIs re-orient)
          (room.players || []).forEach(pl => { try{ pl.color = (pl.color === 'white' ? 'black' : (pl.color === 'black' ? 'white' : pl.color)); }catch(_){ } });
          // flip whose turn it is (since colors swapped)
          if(board.turn) board.turn = (board.turn === 'w' ? 'b' : (board.turn === 'b' ? 'w' : board.turn));
          // bump board version
          board.version = (board.version || 0) + 1;
          // emit an effect to notify clients
          const effect = { id: played.id, type: 'changement_de_camp', playerId: senderId, ts: Date.now() };
          room.activeCardEffects = room.activeCardEffects || [];
          room.activeCardEffects.push(effect);
          played.payload = Object.assign({}, payload, { applied: 'changement_de_camp' });
          try{ io.to(room.id).emit('card:effect:applied', { roomId: room.id, effect }); }catch(_){ }
        }catch(e){ console.error('changement de camp error', e); }
      }
        // promotion: promote one of your pawns to a queen
        else if(cardId === 'promotion' || cardId === 'promote' || (typeof cardId === 'string' && (cardId.indexOf('promotion') !== -1 || cardId.indexOf('promot') !== -1 || cardId.indexOf('promouvoir') !== -1))){
          try{
            const board = room.boardState;
            let target = payload && payload.targetSquare;
            if(!target){ try{ target = socket.data && socket.data.lastSelectedSquare; }catch(e){ target = null; } }
            const roomPlayer = room.players.find(p => p.id === senderId);
            const playerColorShort = (roomPlayer && roomPlayer.color && roomPlayer.color[0]) || null;
            const targetPiece = (board && board.pieces || []).find(p => p.square === target);
            // validate target exists and belongs to the player and is a pawn
            if(!board || !target || !targetPiece || targetPiece.color !== playerColorShort || (targetPiece.type && String(targetPiece.type).toLowerCase() !== 'p')){
              // Invalid target: consume the card and notify owner (promotion failed)
              played.payload = Object.assign({}, payload, { applied: 'promotion_failed', attemptedTo: target });
              try{ const owner = (room.players || []).find(p => p.id === senderId); if(owner && owner.socketId) io.to(owner.socketId).emit('card:effect:applied', { roomId: room.id, effect: { id: played.id, type: 'promotion_failed', playerId: senderId, square: target, ts: Date.now() } }); }catch(_){ }
            } else {
              // mutate the piece: promote to chosen piece (default to queen)
              const oldType = targetPiece.type;
              const chosen = (payload && (payload.promotion || payload.targetPromotion || payload.promoteTo)) || 'q';
              const mapping = { q: 'q', r: 'r', b: 'b', n: 'n' };
              const toType = mapping[String(chosen).toLowerCase()] || 'q';
              targetPiece.type = toType;
              // optional flag to indicate promotion
              targetPiece.promoted = true;
              // emit applied effect for clients to show special UI if desired
              try{
                const effect = { id: played.id, type: 'promotion', pieceId: targetPiece.id, pieceSquare: target, playerId: senderId, ts: Date.now() };
                room.activeCardEffects = room.activeCardEffects || [];
                room.activeCardEffects.push(effect);
                try{ io.to(room.id).emit('card:effect:applied', { roomId: room.id, effect }); }catch(_){ }
              }catch(_){ }
              played.payload = Object.assign({}, payload, { applied: 'promotion', appliedTo: target, fromType: oldType, toType: targetPiece.type });
            }
          }catch(e){ console.error('promotion effect error', e); }
        }
        // kamikaz: destroy one of your pieces and all adjacent pieces
        else if(cardId === 'kamikaz' || (typeof cardId === 'string' && cardId.indexOf('kamikaz') !== -1)){
          try{
            const board = room.boardState;
            // determine target square from payload or last selected
            let target = payload && payload.targetSquare;
            if(!target){ try{ target = socket.data && socket.data.lastSelectedSquare; }catch(e){ target = null; } }
            const roomPlayer = room.players.find(p => p.id === senderId);
            const playerColorShort = (roomPlayer && roomPlayer.color && roomPlayer.color[0]) || null;
            const targetPiece = (board && board.pieces || []).find(p => p.square === target);
            // validate target exists and belongs to the player
            if(!board || !target || !targetPiece || targetPiece.color !== playerColorShort){
              // restore removed card to hand and abort
              try{
                room.hands = room.hands || {};
                room.hands[senderId] = room.hands[senderId] || [];
                if(removed) room.hands[senderId].push(removed);
                room.discard = room.discard || [];
                for(let i = room.discard.length - 1; i >= 0; i--){ if(room.discard[i] && room.discard[i].id === (removed && removed.id)){ room.discard.splice(i,1); break; } }
              }catch(e){ console.error('restore removed card error', e); }
              return cb && cb({ error: 'no valid target' });
            }
            // compute affected squares: target + neighbors
            function neighbors(sq){
              if(!sq) return [];
              const m = String(sq).toLowerCase().match(/^([a-z])([0-9]+)$/i);
              if(!m) return [];
              const file = m[1].charCodeAt(0) - 'a'.charCodeAt(0);
              const rank = parseInt(m[2],10) - 1;
              const w = (board.width || 8), h = (board.height || 8);
              const out = [];
              for(let dx=-1; dx<=1; dx++) for(let dy=-1; dy<=1; dy++){
                const nx = file + dx, ny = rank + dy;
                if(nx<0||ny<0||nx>=w||ny>=h) continue;
                out.push(String.fromCharCode('a'.charCodeAt(0)+nx) + (ny+1));
              }
              return out;
            }
            const affected = neighbors(target);
            const removedPieces = [];
            // remove pieces on affected squares and record them as captured by sender
            for(let i = (board.pieces || []).length - 1; i >= 0; i--){
              const p = board.pieces[i];
              if(p && affected.indexOf(p.square) !== -1){
                const cp = board.pieces.splice(i,1)[0];
                try{
                  room.captured = room.captured || [];
                  const originalOwner = (room.players || []).find(pl => (pl.color && pl.color[0]) === cp.color);
                  room.captured.push({ id: uuidv4().slice(0,8), piece: cp, originalOwnerId: (originalOwner && originalOwner.id) || null, capturedBy: senderId, ts: Date.now() });
                }catch(_){ }
                removedPieces.push({ id: cp.id, square: cp.square, type: cp.type, color: cp.color });
              }
            }
            // bump board version and record effect
            board.version = (board.version || 0) + 1;
            const effect = { id: played.id, type: 'kamikaz', playerId: senderId, targetSquare: target, affectedSquares: affected, removed: removedPieces, ts: Date.now() };
            room.activeCardEffects = room.activeCardEffects || [];
            room.activeCardEffects.push(effect);
            try{ io.to(room.id).emit('card:effect:applied', { roomId: room.id, effect }); }catch(_){ }
            // reuse the mine detonation animation on clients for kamikaz: show the same explosion visual
            try{ io.to(room.id).emit('mine:detonated', { roomId: room.id, square: target }); }catch(_){ }
            played.payload = Object.assign({}, payload, { applied: 'kamikaz', appliedTo: target, affected: affected, removedCount: removedPieces.length });
            // After applying kamikaz, check for victory (kings may have been removed).
            try{
              const end = checkAndHandleVictory(room);
              if(end && end.over){
                // if game over, broadcast final state and stop further turn changes
                try{ sendRoomUpdate(room); }catch(_){ }
              } else {
                // normal behavior: the player immediately loses their turn
                if(board){
                  board.turn = (board.turn === 'w') ? 'b' : 'w';
                  // draw for the next player at the start of their turn
                  const nextColor = board.turn;
                  const nextPlayer = (room.players || []).find(p => (p.color && p.color[0]) === nextColor);
                  if(nextPlayer){ try{ maybeDrawAtTurnStart(room, nextPlayer.id); }catch(_){ } }
                }
              }
            }catch(_){ }
          }catch(e){ console.error('kamikaz effect error', e); }
        }
        // coin coin: teleport one of your pieces from a corner to another empty corner
        else if((typeof cardId === 'string' && (cardId.indexOf('coin') !== -1 || cardId.indexOf('coincoin') !== -1)) || cardId === 'coin_coin'){
          try{
            const board = room.boardState;
            let source = payload && payload.targetSquare;
            if(!source){ try{ source = socket.data && socket.data.lastSelectedSquare; }catch(e){ source = null; } }
            const roomPlayer = room.players.find(p => p.id === senderId);
            const playerColorShort = (roomPlayer && roomPlayer.color && roomPlayer.color[0]) || null;
            const piece = (board && board.pieces || []).find(p => p.square === source);
            // determine corner squares for the current board
            const w = (board && board.width) || 8;
            const h = (board && board.height) || 8;
            const left = 'a';
            const right = String.fromCharCode('a'.charCodeAt(0) + (w - 1));
            const corners = [ left + '1', left + String(h), right + '1', right + String(h) ];
            // validate source exists, belongs to the player and is on a corner
            if(!board || !source || !piece || piece.color !== playerColorShort || corners.indexOf(source) === -1){
              // invalid target: restore card to hand and abort
              try{
                room.hands = room.hands || {};
                room.hands[senderId] = room.hands[senderId] || [];
                if(removed) room.hands[senderId].push(removed);
                room.discard = room.discard || [];
                for(let i = room.discard.length - 1; i >= 0; i--){ if(room.discard[i] && room.discard[i].id === (removed && removed.id)){ room.discard.splice(i,1); break; } }
              }catch(e){ console.error('restore removed card error', e); }
              return cb && cb({ error: 'no valid corner piece selected' });
            }
            // find available destination corners (empty)
            const emptyCorners = corners.filter(c => { return !(board.pieces || []).some(p => p.square === c); });
            // remove the source corner from choices
            const destChoices = emptyCorners.filter(c => c !== source);
            if(!destChoices || destChoices.length === 0){
              // nothing to teleport to: restore card
              try{
                room.hands = room.hands || {};
                room.hands[senderId] = room.hands[senderId] || [];
                if(removed) room.hands[senderId].push(removed);
                room.discard = room.discard || [];
                for(let i = room.discard.length - 1; i >= 0; i--){ if(room.discard[i] && room.discard[i].id === (removed && removed.id)){ room.discard.splice(i,1); break; } }
              }catch(e){ console.error('restore removed card error', e); }
              return cb && cb({ error: 'no empty destination corner available' });
            }
            // instead of teleporting immediately, record an effect that grants this piece the ability
            // to move to any of the available corner squares for one turn
            const effect = { id: played.id, type: 'coincoin', playerId: senderId, pieceId: piece.id, pieceSquare: source, allowedSquares: destChoices.slice(0), remainingTurns: 1, ts: Date.now() };
            room.activeCardEffects = room.activeCardEffects || [];
            room.activeCardEffects.push(effect);
            // bump version so clients refresh legal moves when they request them
            board.version = (board.version || 0) + 1;
            try{ io.to(room.id).emit('card:effect:applied', { roomId: room.id, effect }); }catch(_){ }
            played.payload = Object.assign({}, payload, { applied: 'coincoin', from: source, allowed: destChoices.slice(0) });
          }catch(e){ console.error('coincoin effect error', e); }
        }
        // mélange: permute aléatoirement la position de toutes les pièces (échange entre cases occupées)
        else if((typeof cardId === 'string' && (cardId.indexOf('melange') !== -1 || cardId.indexOf('m\u00E9lange') !== -1 || cardId.indexOf('m\u00E9l') !== -1)) || cardId === 'melange' || cardId === 'm\u00E9lange'){
          try{
            const board = room.boardState;
            if(!board || !Array.isArray(board.pieces) || board.pieces.length === 0){
              // nothing to do; restore card
              try{
                room.hands = room.hands || {};
                room.hands[senderId] = room.hands[senderId] || [];
                if(removed) room.hands[senderId].push(removed);
                room.discard = room.discard || [];
                for(let i = room.discard.length - 1; i >= 0; i--){ if(room.discard[i] && room.discard[i].id === (removed && removed.id)){ room.discard.splice(i,1); break; } }
              }catch(_){ }
              return cb && cb({ error: 'no pieces to shuffle' });
            }
            // gather pieces and compute a random set of distinct destination squares across the whole board
            const pieces = board.pieces;
            const w = board.width || 8; const h = board.height || 8;
            // build full list of all squares on the board
            const allSquares = [];
            for(let yy = 0; yy < h; yy++){
              for(let xx = 0; xx < w; xx++){
                allSquares.push(String.fromCharCode('a'.charCodeAt(0) + xx) + (yy + 1));
              }
            }
            // if there are fewer available squares than pieces (shouldn't happen), abort gracefully
            if(allSquares.length < pieces.length){
              // can't place all pieces uniquely; leave board unchanged
              played.payload = Object.assign({}, payload, { applied: 'melange_failed', reason: 'board_too_small' });
            } else {
              // Fisher-Yates shuffle the full board squares and take first N distinct
              for(let i = allSquares.length - 1; i > 0; i--){ const j = Math.floor(Math.random() * (i + 1)); const tmp = allSquares[i]; allSquares[i] = allSquares[j]; allSquares[j] = tmp; }
              const dests = allSquares.slice(0, pieces.length);
              // assign destinations to pieces in random order
              const newSquareByPieceId = {};
              for(let i = 0; i < pieces.length; i++){ const p = pieces[i]; newSquareByPieceId[p.id] = dests[i]; }
              // apply new squares
              pieces.forEach(p => { try{ p.square = newSquareByPieceId[p.id] || p.square; }catch(_){ } });
              // update any active effects that are bound to pieces (by pieceId) so their pieceSquare follows
              try{
                room.activeCardEffects = room.activeCardEffects || [];
                room.activeCardEffects.forEach(e => {
                  if(!e) return;
                  try{ if(e.pieceId && newSquareByPieceId[e.pieceId]){ e.pieceSquare = newSquareByPieceId[e.pieceId]; } }catch(_){ }
                });
              }catch(_){ }
              played.payload = Object.assign({}, payload, { applied: 'melange', count: pieces.length });
              // bump board version and notify clients
              board.version = (board.version || 0) + 1;
              const effect = { id: played.id, type: 'melange', playerId: senderId, ts: Date.now(), note: 'pieces shuffled' };
              room.activeCardEffects = room.activeCardEffects || [];
              room.activeCardEffects.push(effect);
              try{ io.to(room.id).emit('card:effect:applied', { roomId: room.id, effect }); }catch(_){ }
            }
          }catch(e){ console.error('melange error', e); }
        }
        // révolution: transform pawns into (knight|bishop|rook) randomly, and knights/bishops/rooks into pawns
        else if((typeof cardId === 'string' && (cardId.indexOf('revol') !== -1 || cardId.indexOf('r\u00E9vol') !== -1)) || cardId === 'revolution' || cardId === 'r\u00E9volution'){
          try{
            const board = room.boardState;
            if(!board || !Array.isArray(board.pieces) || board.pieces.length === 0){
              // nothing to do; restore card
              try{
                room.hands = room.hands || {};
                room.hands[senderId] = room.hands[senderId] || [];
                if(removed) room.hands[senderId].push(removed);
                room.discard = room.discard || [];
                for(let i = room.discard.length - 1; i >= 0; i--){ if(room.discard[i] && room.discard[i].id === (removed && removed.id)){ room.discard.splice(i,1); break; } }
              }catch(_){ }
              return cb && cb({ error: 'no pieces to transform' });
            }
            const pieces = board.pieces;
            const transformChoices = ['N','B','R'];
            const mapping = [];
            for(let i = 0; i < pieces.length; i++){
              const p = pieces[i];
              if(!p || !p.type) continue;
              const t = ('' + p.type).toUpperCase();
              if(t === 'P'){
                // pawn -> random among N,B,R
                const choice = transformChoices[Math.floor(Math.random() * transformChoices.length)];
                p.type = choice;
                if(p.promoted) try{ delete p.promoted; }catch(_){ }
                mapping.push({ id: p.id, from: 'P', to: choice });
              } else if(t === 'N' || t === 'B' || t === 'R'){
                // knight/bishop/rook -> pawn
                p.type = 'P';
                if(p.promoted) try{ delete p.promoted; }catch(_){ }
                mapping.push({ id: p.id, from: t, to: 'P' });
              }
            }
            // bump version so clients refresh legal moves when they request them
            board.version = (board.version || 0) + 1;
            try{ io.to(room.id).emit('card:effect:applied', { roomId: room.id, effect: { id: played.id, type: 'revolution', mapping } }); }catch(_){ }
            played.payload = Object.assign({}, payload, { applied: 'revolution', mapping });
          }catch(e){ console.error('revolution effect error', e); }
        }
        // invisible: make one of your pieces invisible to the opponent for a number of turns
        else if(cardId === 'invisible' || (typeof cardId === 'string' && cardId.indexOf('invis') !== -1)){
          try{
            const board = room.boardState;
            let target = payload && payload.targetSquare;
            if(!target){ try{ target = socket.data && socket.data.lastSelectedSquare; }catch(e){ target = null; } }
            const roomPlayer = room.players.find(p => p.id === senderId);
            const playerColorShort = (roomPlayer && roomPlayer.color && roomPlayer.color[0]) || null;
            const targetPiece = (board && board.pieces || []).find(p => p.square === target);
            // validate target exists and belongs to the player
            if(!board || !target || !targetPiece || targetPiece.color !== playerColorShort){
              // restore removed card to hand and remove from discard if necessary
              try{
                room.hands = room.hands || {};
                room.hands[senderId] = room.hands[senderId] || [];
                if(removed) room.hands[senderId].push(removed);
                room.discard = room.discard || [];
                for(let i = room.discard.length - 1; i >= 0; i--){ if(room.discard[i] && room.discard[i].id === (removed && removed.id)){ room.discard.splice(i,1); break; } }
              }catch(e){ console.error('restore removed card error', e); }
              return cb && cb({ error: 'no valid target' });
            }
            // apply invisible effect bound to the piece id so only the owner can see it
            room.activeCardEffects = room.activeCardEffects || [];
            // Mark the piece object itself as invisible so the flag follows the piece when it moves
            try{ targetPiece.invisible = true; }catch(_){ }
            // Permanent invisible effect: do NOT set remainingTurns — the effect persists until explicitly removed by another action.
            const effect = { id: played.id, type: 'invisible', pieceId: targetPiece.id, pieceSquare: target, playerId: senderId, ts: Date.now() };
            room.activeCardEffects.push(effect);
            try{ io.to(room.id).emit('card:effect:applied', { roomId: room.id, effect }); }catch(_){ }
            played.payload = Object.assign({}, payload, { applied: 'invisible', appliedTo: target });
          }catch(e){ console.error('invisible effect error', e); }
        }
        // brouillard de guerre: target a player so their board is fogged (they only see adjacent squares)
        else if(cardId === 'brouillard_de_guerre' || (typeof cardId === 'string' && cardId.indexOf('brouillard') !== -1)){
          try{
            const board = room.boardState;
            // determine target player id: payload.targetPlayerId or the opponent
            let targetPlayerId = payload && payload.targetPlayerId;
            if(!targetPlayerId){
              const opp = (room.players || []).find(p => p.id !== senderId);
              targetPlayerId = opp && opp.id;
            }
            const targetPlayer = (room.players || []).find(p => p.id === targetPlayerId);
            if(!board || !targetPlayer || targetPlayer.id === senderId){
              // restore removed card to hand and abort
              try{ room.hands = room.hands || {}; room.hands[senderId] = room.hands[senderId] || []; if(removed) room.hands[senderId].push(removed); room.discard = room.discard || []; for(let i = room.discard.length-1;i>=0;i--){ if(room.discard[i] && room.discard[i].id === (removed && removed.id)){ room.discard.splice(i,1); break; } } }catch(e){}
              return cb && cb({ error: 'no valid target player' });
            }
            // record brouillard effect for target player
            room.activeCardEffects = room.activeCardEffects || [];
            const effect = { id: played.id, type: 'brouillard', playerId: targetPlayer.id, ts: Date.now(), remainingTurns: (payload && payload.turns) || 4 };
            room.activeCardEffects.push(effect);
            try{ io.to(room.id).emit('card:effect:applied', { roomId: room.id, effect }); }catch(_){}
            played.payload = Object.assign({}, payload, { applied: 'brouillard', appliedToPlayer: targetPlayer.id });
          }catch(e){ console.error('brouillard effect error', e); }
        }
        // anneau: make the board horizontally wrap for the playing player's pieces for this turn
        else if(cardId === 'anneau' || (typeof cardId === 'string' && cardId.indexOf('anneau') !== -1)){
          try{
            // record an anneau effect scoped to the player so their pieces gain wrap behavior
            room.activeCardEffects = room.activeCardEffects || [];
            const effect = { id: played.id, type: 'anneau', playerId: senderId, ts: Date.now(), remainingTurns: (payload && payload.turns) || 1 };
            room.activeCardEffects.push(effect);
            try{ io.to(room.id).emit('card:effect:applied', { roomId: room.id, effect }); }catch(_){}
            played.payload = Object.assign({}, payload, { applied: 'anneau' });
          }catch(e){ console.error('anneau effect error', e); }
        }
        // placement de mines: place a hidden mine on an empty square (hidden from other players)
        else if((typeof cardId === 'string' && cardId.indexOf('mine') !== -1)){
          try{
            const board = room.boardState;
            let target = payload && payload.targetSquare;
            if(!target){ try{ target = socket.data && socket.data.lastSelectedSquare; }catch(e){ target = null; } }
            // validate board and empty target
            const targetOccupied = (board && board.pieces || []).find(p => p.square === target);
            if(!board || !target || targetOccupied){
              // Invalid target: the card is still consumed (player loses the card as requested).
              // We do not restore the removed card to the player's hand. Record in played payload that the placement failed.
              played.payload = Object.assign({}, payload, { applied: 'mine_failed', attemptedTo: target });
              // Notify only the owner that the card was used but the mine was not placed
              try{ const owner = (room.players || []).find(p => p.id === senderId); if(owner && owner.socketId) io.to(owner.socketId).emit('card:effect:applied', { roomId: room.id, effect: { id: played.id, type: 'mine_failed', playerId: senderId, square: target, ts: Date.now() } }); }catch(_){ }
              // continue without creating a mine
            } else {
            // record mine effect scoped to the player; do NOT broadcast location to other players
            room.activeCardEffects = room.activeCardEffects || [];
            const effect = { id: played.id, type: 'mine', playerId: senderId, square: target, ts: Date.now() };
            room.activeCardEffects.push(effect);
            // notify only the owner about the mine placement (keep it hidden from opponents)
            try{
              const owner = (room.players || []).find(p => p.id === senderId);
              if(owner && owner.socketId) io.to(owner.socketId).emit('card:effect:applied', { roomId: room.id, effect });
            }catch(_){ }
            // for the public played record we mark the card as used without revealing the square
            played.payload = Object.assign({}, payload, { applied: 'mine' });
          }
        }catch(e){ console.error('mine placement error', e); }
        }
        // jouer deux fois: grant the playing player one extra move this turn (does not allow another card play)
        else if(cardId === 'jouer_deux_fois' || (typeof cardId === 'string' && cardId.indexOf('jouer') !== -1 && cardId.indexOf('deux') !== -1)){
          try{
            // record double-move effect scoped to the player
            room.activeCardEffects = room.activeCardEffects || [];
            const effect = { id: played.id, type: 'double_move', playerId: senderId, ts: Date.now(), remainingMoves: (payload && payload.moves) || 2 };
            room.activeCardEffects.push(effect);
            try{ io.to(room.id).emit('card:effect:applied', { roomId: room.id, effect }); }catch(_){ }
            played.payload = Object.assign({}, payload, { applied: 'double_move', moves: effect.remainingMoves });
          }catch(e){ console.error('double_move effect error', e); }
        }
  // vol de pièce: transfer ownership of a targeted enemy piece to the playing player
  // Note: do NOT handle "vole ... carte" here (steal-a-card) — that is handled by a separate branch below.
  else if((typeof cardId === 'string' && (cardId.indexOf('vol') !== -1 || cardId.indexOf('vole') !== -1 || cardId.indexOf('steal') !== -1) && !(cardId.indexOf('carte') !== -1 || cardId.indexOf('card') !== -1))){
          try{
            const board = room.boardState;
            let target = payload && payload.targetSquare;
            if(!target){ try{ target = socket.data && socket.data.lastSelectedSquare; }catch(e){ target = null; } }
            const roomPlayer = room.players.find(p => p.id === senderId);
            const playerColorShort = (roomPlayer && roomPlayer.color && roomPlayer.color[0]) || null;
            const targetPiece = (board && board.pieces || []).find(p => p.square === target);
            // validate target exists and belongs to the opponent and is not a king
            if(!board || !target || !targetPiece || targetPiece.color === playerColorShort || (targetPiece.type && String(targetPiece.type).toLowerCase() === 'k')){
              // Invalid target: by convention the card is consumed and not restored. Record failure in payload
              played.payload = Object.assign({}, payload, { applied: 'steal_failed', attemptedTo: target });
              // Notify only the owner that the card was used but the steal did not happen
              try{ const owner = (room.players || []).find(p => p.id === senderId); if(owner && owner.socketId) io.to(owner.socketId).emit('card:effect:applied', { roomId: room.id, effect: { id: played.id, type: 'steal_failed', playerId: senderId, square: target, ts: Date.now() } }); }catch(_){ }
              // continue without creating a steal effect
            } else {
            // perform the theft: change piece color to the player's color
            const oldColor = targetPiece.color;
            targetPiece.color = playerColorShort;

            // record a steal effect so clients can track it if needed
            room.activeCardEffects = room.activeCardEffects || [];
            const originalOwner = (room.players || []).find(p => (p.color && p.color[0]) === oldColor);
            const effect = { id: played.id, type: 'steal', pieceId: targetPiece.id, pieceSquare: target, fromColor: oldColor, toPlayerId: senderId, originalOwnerId: originalOwner && originalOwner.id, playerId: senderId, ts: Date.now() };
            room.activeCardEffects.push(effect);
            try{ io.to(room.id).emit('card:effect:applied', { roomId: room.id, effect }); }catch(_){ }

            played.payload = Object.assign({}, payload, { applied: 'steal', appliedTo: target, fromColor: oldColor });
            // after performing a piece-theft, the playing player immediately loses their turn
            try{
              if(board){
                board.turn = (board.turn === 'w') ? 'b' : 'w';
                // draw for the next player at the start of their turn
                const nextColor = board.turn;
                const nextPlayer = (room.players || []).find(p => (p.color && p.color[0]) === nextColor);
                if(nextPlayer){ try{ maybeDrawAtTurnStart(room, nextPlayer.id); }catch(_){ } }
              }
            }catch(_){ }
            }
          }catch(e){ console.error('steal effect error', e); }
        }
        // vole d'une carte: steal one random card from the target player's hand
        else if((typeof cardId === 'string' && cardId.indexOf('vole') !== -1 && (cardId.indexOf('carte') !== -1 || cardId.indexOf('card') !== -1))){
          try{
            // determine target player id: payload.targetPlayerId or pick the opponent
            let targetPlayerId = payload && payload.targetPlayerId;
            if(!targetPlayerId){ const opp = (room.players || []).find(p => p.id !== senderId); targetPlayerId = opp && opp.id; }
            const targetPlayer = (room.players || []).find(p => p.id === targetPlayerId);
            if(!targetPlayer || targetPlayer.id === senderId){
              // invalid target: consume card and notify owner
              played.payload = Object.assign({}, payload, { applied: 'steal_card_failed', attemptedTo: targetPlayerId });
              try{ const owner = (room.players || []).find(p => p.id === senderId); if(owner && owner.socketId) io.to(owner.socketId).emit('card:effect:applied', { roomId: room.id, effect: { id: played.id, type: 'steal_card_failed', playerId: senderId, targetPlayerId, ts: Date.now() } }); }catch(_){ }
            } else {
              room.hands = room.hands || {};
              const victimHand = room.hands[targetPlayerId] || [];
              if(!victimHand || victimHand.length === 0){
                // nothing to steal
                played.payload = Object.assign({}, payload, { applied: 'steal_card_failed_empty', attemptedTo: targetPlayerId });
                try{ const owner = (room.players || []).find(p => p.id === senderId); if(owner && owner.socketId) io.to(owner.socketId).emit('card:effect:applied', { roomId: room.id, effect: { id: played.id, type: 'steal_card_failed_empty', playerId: senderId, targetPlayerId, ts: Date.now() } }); }catch(_){ }
              } else {
                // pick random card from victim
                const idx = Math.floor(Math.random() * victimHand.length);
                const stolen = victimHand.splice(idx,1)[0];
                // give to stealer
                room.hands[senderId] = room.hands[senderId] || [];
                room.hands[senderId].push(stolen);
                played.payload = Object.assign({}, payload, { applied: 'steal_card', stolenFrom: targetPlayerId, stolenCardId: stolen.cardId || stolen.id });
                // inform the stealer privately about the stolen card details
                try{ const stealer = (room.players || []).find(p => p.id === senderId); if(stealer && stealer.socketId) io.to(stealer.socketId).emit('card:stolen', { roomId: room.id, from: targetPlayerId, card: stolen }); }catch(_){ }
                // inform the victim privately that they lost a card (do not reveal which)
                try{ const victim = (room.players || []).find(p => p.id === targetPlayerId); if(victim && victim.socketId) io.to(victim.socketId).emit('card:lost', { roomId: room.id, lostCount: 1 }); }catch(_){ }
              }
            }
            
          }catch(e){ console.error('steal-card effect error', e); }
          }
          // carte sans effet: consumed but does nothing
          else if((typeof cardId === 'string' && (cardId.indexOf('carte_sans_effet') !== -1 || cardId.indexOf('sans_effet') !== -1 || cardId.indexOf('no_effect') !== -1))){
            try{
              // no game state change; just inform the owner that the card was consumed with no effect
              played.payload = Object.assign({}, payload, { applied: 'no_effect' });
              try{ const owner = (room.players || []).find(p => p.id === senderId); if(owner && owner.socketId) io.to(owner.socketId).emit('card:effect:applied', { roomId: room.id, effect: { id: played.id, type: 'no_effect', playerId: senderId, ts: Date.now() } }); }catch(_){ }
            }catch(e){ console.error('no_effect card error', e); }
          }
          // resurrection: bring back one of your captured pieces and place it on an empty square
          else if((typeof cardId === 'string' && cardId.indexOf('resur') !== -1) || (typeof cardId === 'string' && cardId.indexOf('ressur') !== -1)){
            try{
              const roomPlayer = room.players.find(p => p.id === senderId);
              const playerColorShort = (roomPlayer && roomPlayer.color && roomPlayer.color[0]) || null;
              // list captured pieces that originally belonged to this player
              const available = (room.captured || []).filter(c => c && c.piece && c.piece.color === playerColorShort);
              if(!available || available.length === 0){
                played.payload = Object.assign({}, payload, { applied: 'resurrection_failed_no_captured' });
                try{ const owner = (room.players || []).find(p => p.id === senderId); if(owner && owner.socketId) io.to(owner.socketId).emit('card:effect:applied', { roomId: room.id, effect: { id: played.id, type: 'resurrection_failed_no_captured', playerId: senderId, ts: Date.now() } }); }catch(_){ }
              } else {
                // allow client to specify which captured entry to resurrect
                const selectedId = payload && (payload.captureId || payload.capturedId || payload.targetCapturedId || payload.selectedCapturedId);
                let capturedEntry = null;
                if(selectedId){
                  const idx = (room.captured || []).findIndex(c => c && c.id === selectedId && c.piece && c.piece.color === playerColorShort);
                  if(idx !== -1) capturedEntry = room.captured[idx];
                }
                if(!capturedEntry){
                  // fallback: pick the most recently captured of the player's pieces
                  capturedEntry = available[available.length - 1];
                }
                if(!capturedEntry){
                  played.payload = Object.assign({}, payload, { applied: 'resurrection_failed_no_valid' });
                  try{ const owner = (room.players || []).find(p => p.id === senderId); if(owner && owner.socketId) io.to(owner.socketId).emit('card:effect:applied', { roomId: room.id, effect: { id: played.id, type: 'resurrection_failed_no_valid', playerId: senderId, ts: Date.now() } }); }catch(_){ }
                } else {
                  // placement square
                  let target = payload && payload.targetSquare;
                  if(!target){ try{ target = socket.data && socket.data.lastSelectedSquare; }catch(e){ target = null; } }
                  const board = room.boardState;
                  const occupied = (board && board.pieces || []).find(p => p.square === target);
                  if(!board || !target || occupied){
                    // invalid placement: consume card but report failure to owner
                    played.payload = Object.assign({}, payload, { applied: 'resurrection_failed_bad_square', attemptedTo: target });
                    try{ const owner = (room.players || []).find(p => p.id === senderId); if(owner && owner.socketId) io.to(owner.socketId).emit('card:effect:applied', { roomId: room.id, effect: { id: played.id, type: 'resurrection_failed_bad_square', playerId: senderId, square: target, ts: Date.now() } }); }catch(_){ }
                  } else {
                    // remove captured entry from the capture log
                    for(let i = room.captured.length - 1; i >= 0; i--){ if(room.captured[i] && room.captured[i].id === capturedEntry.id){ room.captured.splice(i,1); break; } }
                    // create a new piece object and place it
                    const orig = capturedEntry.piece || {};
                    const newPiece = Object.assign({}, orig);
                    newPiece.id = ((playerColorShort === 'w') ? 'w_' : 'b_') + (newPiece.type || 'P') + '_' + uuidv4().slice(0,6);
                    newPiece.square = target;
                    newPiece.color = playerColorShort;
                    if(newPiece.promoted) newPiece.promoted = true;
                    board.pieces = board.pieces || [];
                    board.pieces.push(newPiece);
                    // record effect and broadcast
                    const effect = { id: played.id, type: 'resurrection', pieceId: newPiece.id, pieceType: newPiece.type, placedAt: target, playerId: senderId, ts: Date.now() };
                    room.activeCardEffects = room.activeCardEffects || [];
                    room.activeCardEffects.push(effect);
                    try{ io.to(room.id).emit('card:effect:applied', { roomId: room.id, effect }); }catch(_){ }
                    played.payload = Object.assign({}, payload, { applied: 'resurrection', appliedTo: target, resurrectedId: newPiece.id, resurrectedType: newPiece.type });
                  }
                }
              }
            }catch(e){ console.error('resurrection effect error', e); }
          }
      // rebondir: grant a one-time bounce ability to a specific piece (targetSquare required in payload)
      else if(cardId === 'rebondir_sur_les_bords' || cardId === 'rebondir' || (typeof cardId === 'string' && cardId.indexOf('rebondir') !== -1)){
        try{
          const board = room.boardState;
          // allow the client to either provide payload.targetSquare or rely on the last selected square
          let target = payload && payload.targetSquare;
          if(!target){
            try{ target = socket.data && socket.data.lastSelectedSquare; }catch(e){ target = null; }
          }
          // validate target exists and belongs to the player; if invalid, restore card to hand and abort
          const roomPlayer = room.players.find(p => p.id === senderId);
          const playerColorShort = (roomPlayer && roomPlayer.color && roomPlayer.color[0]) || null;
          const targetPiece = (board && board.pieces || []).find(p => p.square === target);
          if(!board || !target || !targetPiece || targetPiece.color !== playerColorShort){
            // restore removed card to hand and remove from discard if necessary
            try{
              room.hands = room.hands || {};
              room.hands[senderId] = room.hands[senderId] || [];
              if(removed) room.hands[senderId].push(removed);
              room.discard = room.discard || [];
              // try to remove the removed card instance from discard (last occurrence)
              for(let i = room.discard.length - 1; i >= 0; i--){ if(room.discard[i] && room.discard[i].id === (removed && removed.id)){ room.discard.splice(i,1); break; } }
            }catch(e){ console.error('restore removed card error', e); }
            return cb && cb({ error: 'no valid target' });
          }
          // apply the rebond effect (also record pieceId so it can be identified after moves)
          room.activeCardEffects = room.activeCardEffects || [];
          room.activeCardEffects.push({ id: played.id, type: 'rebondir', pieceId: targetPiece.id, pieceSquare: target, playerId: senderId });
          played.payload = Object.assign({}, payload, { applied: 'rebondir', appliedTo: target });
        }catch(e){ console.error('rebondir effect error', e); }
      }
    }catch(e){
      console.error('card:play effect error', e);
    }

  room.playedCards.push(played);
  // mark that this player has played a card for this board version (prevents multiple cards per turn)
    try{
    const board = room.boardState;
    if(room.status === 'playing' && board){
      room._cardPlayedThisTurn = room._cardPlayedThisTurn || {};
      room._cardPlayedThisTurn[played.playerId] = true;
    }
  }catch(e){ console.error('mark card played error', e); }
  // emit card played to entire room (informational)
  io.to(roomId).emit('card:played', played);
  // After playing a card, allow the player one free piece move that does NOT consume their turn.
  try{
    room._freeMoveFor = played.playerId; // client may use this flag to enable a free move UI
    // broadcast updated room state so clients can reflect the free-move opportunity
    sendRoomUpdate(room);
    try{ io.to(room.id).emit('card:free_move_allowed', { roomId: room.id, playerId: played.playerId }); }catch(_){ }
  }catch(e){ /* fallback */ sendRoomUpdate(room); }

    cb && cb({ ok: true, played });
  });
});

const PORT = process.env.PORT || 3000;
server.listen(PORT, () => {
  console.log(`ChessNut server listening on port ${PORT}`);
});

// Periodic sweep to ensure victory conditions are detected even if some code path
// didn't call checkAndHandleVictory after mutating the board. This protects against
// missed edge-cases (cards, effects or unexpected flows) by validating rooms once
// per second and emitting `game:over` when appropriate.
setInterval(() => {
  try{
    for(const [id, room] of rooms.entries()){
      try{
        if(!room) continue;
        if(room.status === 'finished') continue;
        // run the victory check (it will emit game:over and set room.status when needed)
        const res = checkAndHandleVictory(room);
        if(res && res.over){
          try{ sendRoomUpdate(room); }catch(_){ }
        }
      }catch(e){ console.error('periodic room check error for', id, e); }
    }
  }catch(e){ console.error('periodic victory sweep error', e); }
}, 1000);
