server.js

const express = require('express');
const http = require('http');
const https = require('https');
const fs = require('fs');
const path = require('path');
const os = require('os');
const { spawn } = require('child_process');
const { WebSocketServer, WebSocket } = require('ws');
const QRCode = require('qrcode');

const PORT = process.env.PORT || 3000;
const USE_HTTPS = process.env.HTTPS === '1';
const TLS_KEY_PATH = process.env.TLS_KEY_PATH || path.join(__dirname, 'certs', 'key.pem');
const TLS_CERT_PATH = process.env.TLS_CERT_PATH || path.join(__dirname, 'certs', 'cert.pem');
const AUTO_TUNNEL = process.env.AUTOTUNNEL !== '0';
const CF_BIN = process.env.CF_BIN || 'cloudflared';
const PUBLIC_URL = process.env.PUBLIC_URL || null; // optional override for controller URL/QR
let protocol = 'http';
let tunnelUrl = null;
let tunnelProc = null;
const HOST = process.env.HOST || getLanAddress();

const app = express();
const server = createServer(app);
const wss = new WebSocketServer({ server });

const TICK_MS = 50;
const LOBBY_IDLE_BEFORE_COUNTDOWN = 4000;
const COUNTDOWN_MS = 3000;
const SESSION_MS = 75000;
const SCORE_SCREEN_MS = 2000;
const FINAL_SCREEN_MS = 6000;
const READY_TILT_THRESHOLD = 0.4;
const CONTROLLER_IDLE_MS = 15000; // drop controllers that go silent
const READY_ACTIVE_MS = 12000; // only count players active in this window for ready checks
const READY_DORMANT_DROP_MS = 8000; // during ready check, drop players that never respond
const READY_LOCK_MS = 3000; // require all-ready for this long before countdown

const palette = [
  '#FF6B6B',
  '#4ECDC4',
  '#FFD166',
  '#9B5DE5',
  '#F15BB5',
  '#00BBF9',
  '#00F5D4',
  '#FF9F1C',
  '#C1FF72',
  '#F25F5C'
];

const players = new Map(); // id -> player data
const controllers = new Map(); // ws -> playerId
const tvs = new Set(); // ws connections

let lastAssignedColor = 0;
let sessionCounter = 1;

const randomId = () => Math.random().toString(36).slice(2, 10);

function clamp(v, min, max) {
  return Math.max(min, Math.min(max, v));
}

['SIGINT', 'SIGTERM', 'exit'].forEach((evt) => {
  process.on(evt, () => {
    if (tunnelProc) {
      tunnelProc.kill();
    }
  });
});

function createServer(app) {
  if (USE_HTTPS) {
    try {
      const key = fs.readFileSync(TLS_KEY_PATH);
      const cert = fs.readFileSync(TLS_CERT_PATH);
      protocol = 'https';
      console.log('Starting HTTPS/WSS server (certs loaded).');
      return https.createServer({ key, cert }, app);
    } catch (err) {
      console.warn(
        `HTTPS was requested (HTTPS=1) but certs could not be loaded from ${TLS_KEY_PATH} and ${TLS_CERT_PATH}: ${err.message}. Falling back to HTTP.`
      );
    }
  }
  protocol = 'http';
  return http.createServer(app);
}

function startCloudflareTunnel() {
  if (tunnelProc) return;
  const args = ['tunnel', '--url', `http://localhost:${PORT}`, '--no-autoupdate', '--loglevel', 'info'];

  try {
    tunnelProc = spawn(CF_BIN, args, { stdio: ['ignore', 'pipe', 'pipe'] });
  } catch (err) {
    console.warn(`Could not start cloudflared (${CF_BIN}): ${err.message}`);
    return;
  }

  const urlRegex = /(https?:\/\/[a-zA-Z0-9.-]+trycloudflare\.com)/i;

  const detectUrl = (chunk) => {
    const text = chunk.toString();
    const match = text.match(urlRegex);
    if (match && match[1]) {
      setTunnelUrl(match[1]);
    }
  };

  tunnelProc.stdout.on('data', detectUrl);

  tunnelProc.stderr.on('data', (data) => {
    console.warn(`cloudflared: ${data.toString().trim()}`);
    detectUrl(data);
  });

  tunnelProc.on('error', (err) => {
    console.warn(`cloudflared failed to start: ${err.message}`);
  });

  tunnelProc.on('exit', (code) => {
    tunnelProc = null;
    if (code) {
      console.warn(`cloudflared exited with code ${code}. Set AUTOTUNNEL=0 to skip tunnel or check your install.`);
    } else {
      console.warn('cloudflared exited.');
    }
  });
}

function pruneInactiveControllers(now) {
  let removed = false;
  controllers.forEach((playerId, ws) => {
    const player = players.get(playerId);
    if (!player) {
      controllers.delete(ws);
      return;
    }
    if (now - (player.lastActive || 0) > CONTROLLER_IDLE_MS) {
      players.delete(playerId);
      controllers.delete(ws);
      if (game.readyCheck) {
        game.readyCheck.ready.delete(playerId);
      }
      try {
        ws.terminate();
      } catch (err) {
        /* ignore */
      }
      removed = true;
    }
  });
  return removed;
}

function pickColor() {
  const color = palette[lastAssignedColor % palette.length];
  lastAssignedColor += 1;
  return color;
}

function getLanAddress() {
  const nets = os.networkInterfaces();
  for (const name of Object.keys(nets)) {
    for (const net of nets[name] || []) {
      if (net.family === 'IPv4' && !net.internal) {
        return net.address;
      }
    }
  }
  return 'localhost';
}

function getControllerUrl() {
  const base = PUBLIC_URL || tunnelUrl || `${protocol}://${HOST}:${PORT}`;
  return `${base.replace(/\/+$/, '')}/controller`;
}

let cachedQrDataUrl = null;

async function getQrDataUrl() {
  if (cachedQrDataUrl) return cachedQrDataUrl;
  cachedQrDataUrl = await QRCode.toDataURL(getControllerUrl());
  return cachedQrDataUrl;
}

function setTunnelUrl(url) {
  if (!url || url === tunnelUrl) return;
  tunnelUrl = url.replace(/\/+$/, '');
  cachedQrDataUrl = null; // force refresh to embed the tunnel URL in the QR
  console.log(`Tunnel active: ${tunnelUrl}`);
  console.log(`Controller URL (tunnel): ${getControllerUrl()}`);
  broadcast({ type: 'tunnel', url: getControllerUrl() });
}

class MicrogameManager {
  constructor() {
    this.state = 'LOBBY';
    this.stateEnteredAt = Date.now();
    this.sessionStartedAt = null;
    this.current = null;
    this.sequence = [];
    this.gameIndex = 0;
    this.readyCheck = null;
    this.mode = 'SHUFFLE'; // 'SHUFFLE' or 'LONGERFORM'
    this.gameSelect = null; // For longerform game selection
  }

  createSequence() {
    if (this.mode === 'LONGERFORM') {
      // Will be set by game selection
      return [this.selectedLongerformGame || 'TILT_RUNNER'];
    }
    // Shuffle mode - mix of minigames
    const minigames = [
      'TILT_BALANCE', 'SHAKE_IT', 'QUICK_DRAW', 'HOT_POTATO',
      'TILT_POUR', 'HOLD_STEADY', 'SIMON_TILT', 'CHICKEN',
      'TAP_FRENZY', 'SNAP_REACT'
    ];
    // Shuffle and pick 7
    const shuffled = minigames.sort(() => Math.random() - 0.5);
    return shuffled.slice(0, 7);
  }

  get longerformGames() {
    return [
      { id: 'TILT_RUNNER', name: 'Tilt Runner', desc: 'Dodge obstacles!' },
      { id: 'SUMO', name: 'Sumo', desc: 'Push them off!' },
      { id: 'TERRITORY', name: 'Territory', desc: 'Claim tiles!' }
    ];
  }

  resetToLobby(now) {
    this.state = 'LOBBY';
    this.stateEnteredAt = now;
    this.sessionStartedAt = null;
    this.current = null;
    this.sequence = [];
    this.gameIndex = 0;
    this.readyCheck = null;
  }

  startReadyCheck(now) {
    this.mode = 'SHUFFLE';
    this.state = 'READY_CHECK';
    this.stateEnteredAt = now;
    this.readyCheck = this.createReadyCheck(now);
  }

  startCountdown(now) {
    this.state = 'COUNTDOWN';
    this.stateEnteredAt = now;
    this.sessionStartedAt = now + COUNTDOWN_MS;
    this.readyCheck = null;

    // For longerform, go to game selection after countdown
    if (this.mode === 'LONGERFORM') {
      this.gameSelect = {
        games: this.longerformGames,
        selections: new Map(), // playerId -> gameId
        selectedGame: 'TILT_RUNNER',
        startedAt: now
      };
    }

    this.gameIndex = 0;
  }

  startGameSelect(now) {
    this.state = 'GAME_SELECT';
    this.stateEnteredAt = now;
    this.gameSelect = {
      games: this.longerformGames,
      selections: new Map(), // playerId -> gameId (based on tilt)
      holdProgress: new Map(), // gameId -> { holdStart, holders }
      confirmedGame: null,
      startedAt: now
    };
  }

  finishGameSelect(now) {
    const winner = this.gameSelect.confirmedGame || 'TILT_RUNNER';
    this.selectedLongerformGame = winner;
    this.sequence = [winner];
    this.gameIndex = 0;
    this.gameSelect = null;
    this.startMicrogame(now);
  }

  startMicrogame(now) {
    if (this.gameIndex >= this.sequence.length) {
      this.toFinal(now);
      return;
    }
    if (!this.sessionStartedAt) {
      this.sessionStartedAt = now;
    }
    const id = this.sequence[this.gameIndex];
    this.gameIndex++;
    this.current = this.buildMicrogame(id, now);
    this._lastUpdateAt = now; // Reset update timing
    this.state = 'MICROGAME_ACTIVE';
    this.stateEnteredAt = now;
  }

  toScoreState(now) {
    this.state = 'MICROGAME_SCORE';
    this.stateEnteredAt = now;
  }

  toFinal(now) {
    this.state = 'FINAL_SCORE';
    this.stateEnteredAt = now;
  }

  startPlayAgain(now) {
    this.state = 'PLAY_AGAIN';
    this.stateEnteredAt = now;
    this.playAgain = {
      stayPlayers: new Set(), // Players who tilted right to stay
      leavePlayers: new Set(), // Players who tilted left to leave
      startedAt: now
    };
  }

  finishPlayAgain(now) {
    // Remove players who chose to leave
    this.playAgain.leavePlayers.forEach((playerId) => {
      removePlayerById(playerId);
    });

    // Reset scores for staying players
    this.resetScores();

    // If anyone is staying, go to ready check
    if (players.size > 0) {
      this.startReadyCheck(now);
    } else {
      this.resetToLobby(now);
    }

    this.playAgain = null;
  }

  tick(now) {
    if (players.size === 0 && this.state !== 'LOBBY') {
      this.resetToLobby(now);
      return;
    }
    switch (this.state) {
      case 'LOBBY': {
        if (players.size > 0 && now - this.stateEnteredAt > LOBBY_IDLE_BEFORE_COUNTDOWN) {
          this.startReadyCheck(now);
        }
        break;
      }
      case 'READY_CHECK': {
        this.syncReadyRoster();
        const activeCount = activePlayerIds(now, this.readyCheck?.startedAt || now - READY_ACTIVE_MS).size;
        const readyCount = this.readyCheck ? this.readyCheck.ready.size : 0;
        const allReady = activeCount > 0 && readyCount >= activeCount;
        if (this.readyCheck) {
          // compute mode by majority
          const votes = { SHUFFLE: 0, LONGERFORM: 0 };
          players.forEach((p) => {
            const pick = this.readyCheck.selections.get(p.id) || 'SHUFFLE';
            votes[pick] = (votes[pick] || 0) + 1;
          });
          this.mode = votes.LONGERFORM > votes.SHUFFLE ? 'LONGERFORM' : 'SHUFFLE';
          this.readyCheck.choice = this.mode;
          if (allReady) {
            if (!this.readyCheck.allReadySince) this.readyCheck.allReadySince = now;
            if (now - this.readyCheck.allReadySince >= READY_LOCK_MS) {
              this.startCountdown(now);
            }
          } else {
            this.readyCheck.allReadySince = null;
          }
        }
        if (activeCount === 0 && now - (this.readyCheck?.startedAt || now) > READY_ACTIVE_MS) {
          this.resetToLobby(now);
        } else if (this.readyCheck && now - this.readyCheck.startedAt > READY_DORMANT_DROP_MS) {
          players.forEach((p) => {
            if ((p.lastActive || 0) < this.readyCheck.startedAt) {
              removePlayerById(p.id);
            }
          });
        }
        break;
      }
      case 'COUNTDOWN': {
        if (now - this.stateEnteredAt >= COUNTDOWN_MS) {
          if (this.mode === 'LONGERFORM') {
            this.startGameSelect(now);
          } else {
            this.sequence = this.createSequence();
            this.startMicrogame(now);
          }
        }
        break;
      }
      case 'GAME_SELECT': {
        if (!this.gameSelect) break;

        const HOLD_DURATION = 2000; // 2 seconds to confirm
        const gs = this.gameSelect;

        // Track which games have holders
        const gameHolders = {};
        this.longerformGames.forEach(g => gameHolders[g.id] = []);

        // Check each player's tilt position and hold state
        players.forEach((p) => {
          const tiltX = p.tiltX || 0;
          let gameId;
          if (tiltX < -0.3) {
            gameId = 'TILT_RUNNER';
          } else if (tiltX > 0.3) {
            gameId = 'TERRITORY';
          } else {
            gameId = 'SUMO';
          }

          // Update their selection
          gs.selections.set(p.id, gameId);

          // If holding, add to holders for that game
          if (p.holding) {
            gameHolders[gameId].push(p.id);
          }
        });

        // Update hold progress for each game
        this.longerformGames.forEach(g => {
          const holders = gameHolders[g.id];
          const progress = gs.holdProgress.get(g.id);

          if (holders.length > 0) {
            // Someone is holding on this game
            if (!progress || progress.holders.length === 0) {
              // Start tracking
              gs.holdProgress.set(g.id, {
                holdStart: now,
                holders: holders
              });
            } else {
              // Check if hold duration reached
              const elapsed = now - progress.holdStart;
              if (elapsed >= HOLD_DURATION) {
                gs.confirmedGame = g.id;
                this.finishGameSelect(now);
                return;
              }
            }
          } else {
            // No one holding, reset progress
            gs.holdProgress.set(g.id, { holdStart: null, holders: [] });
          }
        });

        break;
      }
      case 'MICROGAME_ACTIVE': {
        if (this.current && typeof this.current.update === 'function') {
          // Calculate delta since last update
          const delta = now - (this._lastUpdateAt || now);
          this._lastUpdateAt = now;
          this.current.update(now, delta);
        }
        // Check for game end (time or early termination)
        const shouldEnd = this.current && (
          now >= this.current.endsAt ||
          (typeof this.current.shouldEndEarly === 'function' && this.current.shouldEndEarly())
        );
        if (shouldEnd) {
          this.finishMicrogame(now);
        }
        break;
      }
      case 'MICROGAME_SCORE': {
        if (now - this.stateEnteredAt >= SCORE_SCREEN_MS) {
          // Check if we've played all games or session time exceeded
          const sessionTimeUp = this.sessionStartedAt && now - this.sessionStartedAt >= SESSION_MS;
          const allGamesPlayed = this.gameIndex >= this.sequence.length;

          if (sessionTimeUp || allGamesPlayed) {
            this.toFinal(now);
          } else {
            this.startMicrogame(now);
          }
        }
        break;
      }
      case 'FINAL_SCORE': {
        if (now - this.stateEnteredAt >= FINAL_SCREEN_MS) {
          // Go to play again screen instead of directly to lobby
          this.startPlayAgain(now);
        }
        break;
      }
      case 'PLAY_AGAIN': {
        const PLAY_AGAIN_DURATION = 6000; // 6 seconds to decide

        if (this.playAgain) {
          // Update player choices based on tilt
          players.forEach((p) => {
            const tiltX = p.tiltX || 0;
            if (tiltX > 0.3) {
              // Tilt right = stay
              this.playAgain.stayPlayers.add(p.id);
              this.playAgain.leavePlayers.delete(p.id);
            } else if (tiltX < -0.3) {
              // Tilt left = leave
              this.playAgain.leavePlayers.add(p.id);
              this.playAgain.stayPlayers.delete(p.id);
            }
          });

          // End after duration
          if (now - this.stateEnteredAt >= PLAY_AGAIN_DURATION) {
            // Anyone who didn't choose stays by default
            players.forEach((p) => {
              if (!this.playAgain.stayPlayers.has(p.id) && !this.playAgain.leavePlayers.has(p.id)) {
                this.playAgain.stayPlayers.add(p.id);
              }
            });
            this.finishPlayAgain(now);
          }
        }
        break;
      }
      default:
        break;
    }
  }

  finishMicrogame(now) {
    if (!this.current) return;
    this.current.finish(now);
    this.toScoreState(now);
  }

  createReadyCheck(now) {
    const cue = 'HOLD';
    const prompt = 'Everybody press and hold';
    const instruction = 'Lean left for Minigames, right for Longerform';
    return {
      type: cue,
      prompt,
      instruction,
      ready: new Set(),
      startedAt: now,
      lastProgressAt: now,
      allReadySince: null,
      selections: new Map(), // playerId -> mode
      choice: this.mode
    };
  }

  markReady(playerId) {
    if (this.state !== 'READY_CHECK' || !this.readyCheck || !players.has(playerId)) return;
    this.readyCheck.ready.add(playerId);
    this.readyCheck.lastProgressAt = Date.now();
  }

  syncReadyRoster() {
    if (!this.readyCheck) return;
    const now = Date.now();
    [...this.readyCheck.ready].forEach((id) => {
      const p = players.get(id);
      const inactive = !p || now - (p.lastActive || 0) > READY_ACTIVE_MS;
      if (inactive) this.readyCheck.ready.delete(id);
    });
  }

  readyCheckPayload() {
    if (!this.readyCheck) return null;
    const selections = { shuffleIds: [], longerformIds: [] };
    this.readyCheck.selections.forEach((mode, pid) => {
      if (mode === 'LONGERFORM') selections.longerformIds.push(pid);
      else selections.shuffleIds.push(pid);
    });
    return {
      type: this.readyCheck.type,
      prompt: this.readyCheck.prompt,
      instruction: this.readyCheck.instruction,
      readyIds: [...this.readyCheck.ready],
      startedAt: this.readyCheck.startedAt,
      allReadySince: this.readyCheck.allReadySince,
      choice: this.readyCheck.choice || this.mode,
      selections
    };
  }

  resetScores() {
    players.forEach((p) => {
      p.score = 0;
      p.streak = 0;
    });
    sessionCounter += 1;
  }

  buildMicrogame(id, now) {
    // Import game classes dynamically based on ID
    const gameClasses = {
      // Minigames
      TILT_BALANCE: require('./server/games/minigames/TiltBalance'),
      SHAKE_IT: require('./server/games/minigames/ShakeIt'),
      QUICK_DRAW: require('./server/games/minigames/QuickDraw'),
      HOT_POTATO: require('./server/games/minigames/HotPotato'),
      TILT_POUR: require('./server/games/minigames/TiltPour'),
      HOLD_STEADY: require('./server/games/minigames/HoldSteady'),
      SIMON_TILT: require('./server/games/minigames/SimonTilt'),
      CHICKEN: require('./server/games/minigames/Chicken'),
      TAP_FRENZY: require('./server/games/minigames/TapFrenzy'),
      SNAP_REACT: require('./server/games/minigames/SnapReact'),
      // Longerform
      TILT_RUNNER: require('./server/games/longerform/TiltRunner'),
      SUMO: require('./server/games/longerform/Sumo'),
      TERRITORY: require('./server/games/longerform/TerritoryControl')
    };

    const GameClass = gameClasses[id];
    if (!GameClass) {
      console.warn(`Unknown game: ${id}`);
      return {
        id: 'UNKNOWN',
        title: '???',
        prompt: '???',
        duration: 3000,
        startedAt: now,
        endsAt: now + 3000,
        perPlayer: new Map(),
        extra: {},
        update: () => {},
        finish: () => {},
        getStatePayload: () => ({ id: 'UNKNOWN', title: '???', prompt: '???', startedAt: now, endsAt: now + 3000, duration: 3000, extra: {} })
      };
    }

    const gameInstance = new GameClass(players);

    // Wrap the game instance to match old interface
    return {
      id: gameInstance.id,
      title: gameInstance.title,
      prompt: gameInstance.prompt,
      duration: gameInstance.duration,
      startedAt: gameInstance.startedAt,
      endsAt: gameInstance.endsAt,
      perPlayer: gameInstance.perPlayer,
      extra: gameInstance.extra,
      update: (ts) => {
        const delta = ts - (gameInstance._lastTick || ts);
        gameInstance._lastTick = ts;
        gameInstance.update(ts, delta);
      },
      finish: (ts) => {
        gameInstance.finish(ts);
        // Apply scores from results
        gameInstance.results.forEach((result, playerId) => {
          const player = players.get(playerId);
          if (player) {
            applyScore(player, result.score);
          }
        });
      },
      shouldEndEarly: () => gameInstance.shouldEndEarly ? gameInstance.shouldEndEarly() : false,
      // Input handlers
      onTap: (pid, ts) => gameInstance.onTap(pid, ts),
      onHold: (pid, down, ts) => gameInstance.onHold(pid, down, ts),
      onTilt: (pid, tiltX, ts) => gameInstance.onTilt(pid, tiltX, ts),
      onShake: (pid, intensity, ts) => gameInstance.onShake(pid, intensity, ts),
      getStatePayload: () => gameInstance.getStatePayload ? gameInstance.getStatePayload() : {
        id: gameInstance.id,
        title: gameInstance.title,
        prompt: gameInstance.prompt,
        startedAt: gameInstance.startedAt,
        endsAt: gameInstance.endsAt,
        duration: gameInstance.duration,
        extra: gameInstance.extra
      }
    };
  }
}

function activePlayerIds(now, since) {
  const active = new Set();
  players.forEach((p) => {
    const last = p.lastActive || 0;
    const fresh = now - last <= READY_ACTIVE_MS;
    const afterSince = typeof since === 'number' ? last >= since : true;
    if (fresh && afterSince) {
      active.add(p.id);
    }
  });
  return active;
}

const game = new MicrogameManager();

function applyScore(player, amount) {
  const streakBonus = player.streak ? Math.floor(player.streak * 4) : 0;
  player.score += amount + streakBonus;
  if (amount >= 60) {
    player.streak = (player.streak || 0) + 1;
  } else {
    player.streak = 0;
  }
  player.lastScore = amount;
}

function sanitizeName(name) {
  const clean = (name || '').trim().slice(0, 18);
  return clean || 'Guest';
}

function broadcast(payload) {
  const msg = JSON.stringify(payload);
  [...tvs, ...controllers.keys()].forEach((ws) => {
    if (ws.readyState === WebSocket.OPEN) ws.send(msg);
  });
}

function send(ws, payload) {
  if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify(payload));
}

function handleTap(playerId) {
  const micro = game.current;
  if (!micro) return;
  // Forward tap to game
  if (micro.onTap) {
    micro.onTap(playerId, Date.now());
  }
}

function handleHold(playerId, isDown, timestamp) {
  if (game.state === 'READY_CHECK' && game.readyCheck) {
    if (isDown) {
      game.markReady(playerId);
    } else {
      game.readyCheck.ready.delete(playerId);
      game.readyCheck.allReadySince = null;
    }
    game.readyCheck.lastProgressAt = timestamp;
  }
  const micro = game.current;
  if (!micro) return;
  // Forward hold to game
  if (micro.onHold) {
    micro.onHold(playerId, isDown, timestamp);
  }
}

function handleTilt(playerId) {
  if (game.state === 'READY_CHECK' && game.readyCheck && game.readyCheck.type === 'LEAN') {
    const player = players.get(playerId);
    if (player && Math.abs(player.tiltX) >= READY_TILT_THRESHOLD) {
      game.markReady(playerId);
    }
  }
  if (game.state === 'READY_CHECK' && game.readyCheck) {
    const player = players.get(playerId);
    if (player && Math.abs(player.tiltX) > 0.25) {
      // Lean left = Shuffle (minigames), right = Longerform
      game.readyCheck.selections.set(playerId, player.tiltX > 0 ? 'LONGERFORM' : 'SHUFFLE');
    }
  }
  // Game selection for longerform
  if (game.state === 'GAME_SELECT' && game.gameSelect) {
    const player = players.get(playerId);
    if (player) {
      const tiltX = player.tiltX || 0;
      const games = game.longerformGames;
      // Map tilt to game index: left = first, center = second, right = third
      let gameIndex;
      if (tiltX < -0.3) {
        gameIndex = 0; // Left = Tilt Runner
      } else if (tiltX > 0.3) {
        gameIndex = 2; // Right = Territory
      } else {
        gameIndex = 1; // Center = Sumo
      }
      game.gameSelect.selections.set(playerId, games[gameIndex].id);
    }
  }
  const micro = game.current;
  if (!micro) return;
  // Forward tilt to game
  if (micro.onTilt) {
    const player = players.get(playerId);
    if (player) {
      micro.onTilt(playerId, player.tiltX, Date.now());
    }
  }
}

function playerList() {
  return [...players.values()].map((p) => ({
    id: p.id,
    name: p.name,
    color: p.color,
    score: p.score,
    tiltX: p.tiltX,
    holding: p.holding,
    lastScore: p.lastScore || 0,
    streak: p.streak || 0,
    connected: true,
    ready: game.readyCheck ? game.readyCheck.ready.has(p.id) : false,
    lastActive: p.lastActive || 0,
    lastTap: p.lastTapAt || 0
  }));
}

function currentStatePayload() {
  const now = Date.now();

  // Build game select payload if in that state
  let gameSelectPayload = null;
  if (game.state === 'GAME_SELECT' && game.gameSelect) {
    const gs = game.gameSelect;
    const selections = {};
    gs.selections.forEach((gameId, playerId) => {
      if (!selections[gameId]) selections[gameId] = [];
      selections[gameId].push(playerId);
    });

    // Build hold progress info
    const holdProgress = {};
    const HOLD_DURATION = 2000;
    gs.holdProgress.forEach((progress, gameId) => {
      if (progress.holdStart && progress.holders.length > 0) {
        const elapsed = now - progress.holdStart;
        holdProgress[gameId] = {
          progress: Math.min(1, elapsed / HOLD_DURATION),
          holders: progress.holders
        };
      }
    });

    gameSelectPayload = {
      games: gs.games,
      selections,
      holdProgress
    };
  }

  // Build play again payload if in that state
  let playAgainPayload = null;
  if (game.state === 'PLAY_AGAIN' && game.playAgain) {
    const PLAY_AGAIN_DURATION = 6000;
    playAgainPayload = {
      stayPlayerIds: [...game.playAgain.stayPlayers],
      leavePlayerIds: [...game.playAgain.leavePlayers],
      timeRemaining: Math.max(0, PLAY_AGAIN_DURATION - (now - game.stateEnteredAt))
    };
  }

  return {
    type: 'state',
    at: now,
    session: sessionCounter,
    state: game.state,
    mode: game.mode,
    gameProgress: {
      current: game.gameIndex,
      total: game.sequence.length
    },
    countdownRemaining: game.state === 'COUNTDOWN' ? Math.max(0, game.stateEnteredAt + COUNTDOWN_MS - now) : 0,
    gameSelect: gameSelectPayload,
    playAgain: playAgainPayload,
    microgame: game.current
      ? {
          id: game.current.id,
          title: game.current.title,
          prompt: game.current.prompt,
          startedAt: game.current.startedAt,
          endsAt: game.current.endsAt,
          duration: game.current.duration,
          extra: game.current.extra || {}
        }
      : null,
    players: playerList(),
    readyCheck: game.readyCheckPayload()
  };
}

function removePlayerBySocket(ws) {
  const playerId = controllers.get(ws);
  if (playerId && players.has(playerId)) {
    players.delete(playerId);
  }
  controllers.delete(ws);
  if (playerId && game.readyCheck) {
    game.readyCheck.ready.delete(playerId);
  }
}

function removePlayerById(playerId) {
  if (!players.has(playerId)) return false;
  players.delete(playerId);
  if (game.readyCheck) {
    game.readyCheck.ready.delete(playerId);
  }
  // Close any sockets tied to this player.
  controllers.forEach((pid, socket) => {
    if (pid === playerId) {
      controllers.delete(socket);
      try {
        socket.close();
      } catch (err) {
        /* ignore */
      }
    }
  });
  return true;
}

function wireWebSocket(ws) {
  ws.on('message', (raw) => {
    let msg;
    try {
      msg = JSON.parse(raw);
    } catch (err) {
      return;
    }
    const playerId = controllers.get(ws);
    if (msg.type === 'joinTV') {
      tvs.add(ws);
      send(ws, { type: 'hello', role: 'tv', controllerUrl: getControllerUrl() });
      return;
    }
    if (msg.type === 'join' && msg.role === 'controller') {
      const id = randomId();
      const name = sanitizeName(msg.name);
      const color = pickColor();
      console.log(`Controller join: ${name} (${id})`);
      players.set(id, {
        id,
        name,
        color,
        score: 0,
        streak: 0,
        tiltX: 0,
        holding: false,
        lastTapAt: 0,
        lastActive: Date.now()
      });
      controllers.set(ws, id);
      send(ws, { type: 'joined', playerId: id, color, name, controllerUrl: getControllerUrl() });
      broadcast(currentStatePayload());
      return;
    }
    if (msg.type === 'ready') {
      game.markReady(playerId);
      return;
    }

    if (!playerId) return;
    const player = players.get(playerId);
    if (!player) return;
    player.lastActive = Date.now();

    if (msg.type === 'tilt') {
      player.tiltX = clamp(msg.tiltX || 0, -1.2, 1.2);
      handleTilt(playerId);
    }
    if (msg.type === 'tap') {
      player.lastTapAt = player.lastActive;
      handleTap(playerId);
    }
    if (msg.type === 'hold') {
      player.holding = !!msg.down;
      handleHold(playerId, !!msg.down, player.lastActive);
    }
    if (msg.type === 'shake') {
      // Handle shake input for games
      const micro = game.current;
      if (micro && micro.onShake) {
        micro.onShake(playerId, msg.intensity || 0, player.lastActive);
      }
    }
  });

  ws.on('close', () => {
    tvs.delete(ws);
    removePlayerBySocket(ws);
    broadcast(currentStatePayload());
  });
}

wss.on('connection', (ws, req) => {
  console.log('WS connection from', req?.socket?.remoteAddress || 'unknown');
  wireWebSocket(ws);
});

setInterval(() => {
  const now = Date.now();
  const pruned = pruneInactiveControllers(now);
  game.tick(now);
  if (pruned) {
    cachedQrDataUrl = null; // force QR refresh if host changes after drop
  }
  broadcast(currentStatePayload());
}, TICK_MS);

app.use(
  express.static(path.join(__dirname, 'public'), {
    extensions: ['html'] // allow /tv and /controller to resolve to their html files
  })
);

app.get('/info', async (req, res) => {
  const qr = await getQrDataUrl();
  res.json({
    controllerUrl: getControllerUrl(),
    qr,
    host: HOST,
    tunnel: tunnelUrl
  });
});

app.use((req, res) => {
  res.sendFile(path.join(__dirname, 'public', 'index.html'));
});

server.listen(PORT, () => {
  console.log(`Party server running on ${protocol}://localhost:${PORT}`);
  console.log(`Controller URL: ${getControllerUrl()}`);
  if (AUTO_TUNNEL) {
    startCloudflareTunnel();
  } else if (PUBLIC_URL) {
    setTunnelUrl(PUBLIC_URL);
  }
});