dubs-server 1.0.0

package/controllers/survivorAdminController.js

@@ -0,0 +1,887 @@
+/**
+ * Survivor Admin Controller
+ * Admin operations for March Madness Survivor Pool
+ *
+ * Features:
+ * - Generate random bracket (for testing)
+ * - Manual team selection (for real Selection Sunday)
+ * - Simulate game results
+ * - Advance rounds
+ * - Manage deadlines
+ * - Track eliminations
+ */
+
+const { pool } = require('../services/db');
+const { NCAA_TEAMS, CONFERENCES } = require('../data/ncaaTeams');
+
+const REGIONS = ['SOUTH', 'WEST', 'EAST', 'MIDWEST'];
+const SEEDS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
+
+const ROUND_NAMES = {
+  1: 'First Four',
+  2: 'Round of 64',
+  3: 'Round of 32',
+  4: 'Sweet 16',
+  5: 'Elite 8',
+  6: 'Final Four',
+  7: 'Championship'
+};
+
+/**
+ * Get all NCAA teams for selection
+ */
+function getAllTeams() {
+  return {
+    teams: NCAA_TEAMS,
+    conferences: CONFERENCES,
+    count: NCAA_TEAMS.length
+  };
+}
+
+/**
+ * Generate a random 68-team bracket
+ * Selects 68 random teams from the 364 D1 teams and assigns them to regions/seeds
+ */
+async function generateRandomBracket(poolId) {
+  // Shuffle and pick 68 teams
+  const shuffled = [...NCAA_TEAMS].sort(() => Math.random() - 0.5);
+  const selected = shuffled.slice(0, 68);
+
+  // Assign to regions and seeds
+  // 16 teams per region = 64 teams + 4 First Four teams
+  const bracket = [];
+  let teamIndex = 0;
+
+  for (const region of REGIONS) {
+    for (const seed of SEEDS) {
+      if (teamIndex < 64) {
+        bracket.push({
+          team: selected[teamIndex],
+          region,
+          seed,
+          isFirstFour: false
+        });
+        teamIndex++;
+      }
+    }
+  }
+
+  // First Four teams (4 extra teams for play-in games)
+  // In real tournament, First Four involves 4 matchups of the lowest seeds
+  for (let i = 64; i < 68; i++) {
+    bracket.push({
+      team: selected[i],
+      region: REGIONS[i - 64],
+      seed: 16, // First Four are typically 16 seeds or 11/12 seeds
+      isFirstFour: true
+    });
+  }
+
+  // Clear existing games for this pool
+  await pool.query('DELETE FROM survivor_tournament_games WHERE pool_id = $1', [poolId]);
+
+  // Generate Round 1 matchups (Round of 64)
+  // 1 vs 16, 8 vs 9, 5 vs 12, 4 vs 13, 6 vs 11, 3 vs 14, 7 vs 10, 2 vs 15
+  const seedMatchups = [
+    [1, 16], [8, 9], [5, 12], [4, 13], [6, 11], [3, 14], [7, 10], [2, 15]
+  ];
+
+  const games = [];
+  let gameId = 1;
+
+  for (const region of REGIONS) {
+    const regionTeams = bracket.filter(t => t.region === region && !t.isFirstFour);
+
+    for (const [seed1, seed2] of seedMatchups) {
+      const team1 = regionTeams.find(t => t.seed === seed1);
+      const team2 = regionTeams.find(t => t.seed === seed2);
+
+      if (team1 && team2) {
+        games.push({
+          poolId,
+          round: 2, // Round of 64
+          espnGameId: `sim-r64-${region.toLowerCase()}-${gameId}`,
+          region,
+          team1Id: team1.team.id,
+          team1Name: team1.team.name,
+          team1Seed: team1.seed,
+          team1Logo: team1.team.logo,
+          team2Id: team2.team.id,
+          team2Name: team2.team.name,
+          team2Seed: team2.seed,
+          team2Logo: team2.team.logo,
+          status: 'scheduled'
+        });
+        gameId++;
+      }
+    }
+  }
+
+  // Insert games
+  for (const game of games) {
+    await pool.query(
+      `INSERT INTO survivor_tournament_games
+       (pool_id, round, espn_game_id, region, team1_id, team1_name, team1_seed, team1_logo,
+        team2_id, team2_name, team2_seed, team2_logo, status)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)`,
+      [
+        game.poolId, game.round, game.espnGameId, game.region,
+        game.team1Id, game.team1Name, game.team1Seed, game.team1Logo,
+        game.team2Id, game.team2Name, game.team2Seed, game.team2Logo,
+        game.status
+      ]
+    );
+  }
+
+  // Update pool status to active and set to Round 2 (Round of 64)
+  await pool.query(
+    `UPDATE survivor_pools
+     SET status = 'active', current_round = 2, updated_at = NOW()
+     WHERE id = $1`,
+    [poolId]
+  );
+
+  return {
+    message: 'Random bracket generated',
+    teamsSelected: 68,
+    gamesCreated: games.length,
+    bracket: bracket.map(b => ({
+      team: b.team.name,
+      region: b.region,
+      seed: b.seed
+    }))
+  };
+}
+
+/**
+ * Set bracket manually (for real Selection Sunday)
+ * teams: Array of { teamId, region, seed }
+ */
+async function setManualBracket(poolId, teams) {
+  if (teams.length !== 68 && teams.length !== 64) {
+    throw new Error(`Expected 64 or 68 teams, got ${teams.length}`);
+  }
+
+  // Validate teams exist
+  const teamMap = new Map(NCAA_TEAMS.map(t => [t.id, t]));
+  const bracket = teams.map(t => {
+    const team = teamMap.get(t.teamId);
+    if (!team) {
+      throw new Error(`Unknown team ID: ${t.teamId}`);
+    }
+    return {
+      team,
+      region: t.region,
+      seed: t.seed
+    };
+  });
+
+  // Clear existing games
+  await pool.query('DELETE FROM survivor_tournament_games WHERE pool_id = $1', [poolId]);
+
+  // Generate matchups (same logic as random)
+  const seedMatchups = [
+    [1, 16], [8, 9], [5, 12], [4, 13], [6, 11], [3, 14], [7, 10], [2, 15]
+  ];
+
+  const games = [];
+  let gameId = 1;
+
+  for (const region of REGIONS) {
+    const regionTeams = bracket.filter(t => t.region === region);
+
+    for (const [seed1, seed2] of seedMatchups) {
+      const team1 = regionTeams.find(t => t.seed === seed1);
+      const team2 = regionTeams.find(t => t.seed === seed2);
+
+      if (team1 && team2) {
+        games.push({
+          poolId,
+          round: 2,
+          espnGameId: `man-r64-${region.toLowerCase()}-${gameId}`,
+          region,
+          team1Id: team1.team.id,
+          team1Name: team1.team.name,
+          team1Seed: team1.seed,
+          team1Logo: team1.team.logo,
+          team2Id: team2.team.id,
+          team2Name: team2.team.name,
+          team2Seed: team2.seed,
+          team2Logo: team2.team.logo,
+          status: 'scheduled'
+        });
+        gameId++;
+      }
+    }
+  }
+
+  // Insert games
+  for (const game of games) {
+    await pool.query(
+      `INSERT INTO survivor_tournament_games
+       (pool_id, round, espn_game_id, region, team1_id, team1_name, team1_seed, team1_logo,
+        team2_id, team2_name, team2_seed, team2_logo, status)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)`,
+      [
+        game.poolId, game.round, game.espnGameId, game.region,
+        game.team1Id, game.team1Name, game.team1Seed, game.team1Logo,
+        game.team2Id, game.team2Name, game.team2Seed, game.team2Logo,
+        game.status
+      ]
+    );
+  }
+
+  // Update pool status
+  await pool.query(
+    `UPDATE survivor_pools
+     SET status = 'active', current_round = 2, updated_at = NOW()
+     WHERE id = $1`,
+    [poolId]
+  );
+
+  return {
+    message: 'Manual bracket set',
+    teamsSelected: teams.length,
+    gamesCreated: games.length
+  };
+}
+
+/**
+ * Set round deadline
+ * minutes: Number of minutes from now
+ */
+async function setDeadline(poolId, minutes) {
+  const deadline = new Date(Date.now() + minutes * 60 * 1000);
+
+  await pool.query(
+    `UPDATE survivor_pools
+     SET round_deadline = $2, updated_at = NOW()
+     WHERE id = $1`,
+    [poolId, deadline]
+  );
+
+  return {
+    message: `Deadline set to ${minutes} minutes from now`,
+    deadline: deadline.toISOString(),
+    deadlineLocal: deadline.toLocaleString()
+  };
+}
+
+/**
+ * Clear deadline (no deadline)
+ */
+async function clearDeadline(poolId) {
+  await pool.query(
+    `UPDATE survivor_pools
+     SET round_deadline = NULL, updated_at = NOW()
+     WHERE id = $1`,
+    [poolId]
+  );
+
+  return { message: 'Deadline cleared' };
+}
+
+/**
+ * Simulate current round results
+ * mode: 'chalk' (favorites win), 'random' (50/50), 'chaos' (upsets likely), 'manual'
+ */
+async function simulateRound(poolId, mode = 'random', manualResults = null) {
+  // Get current round
+  const poolResult = await pool.query(
+    'SELECT current_round FROM survivor_pools WHERE id = $1',
+    [poolId]
+  );
+
+  if (poolResult.rows.length === 0) {
+    throw new Error('Pool not found');
+  }
+
+  const currentRound = poolResult.rows[0].current_round;
+
+  // Get games for current round
+  const gamesResult = await pool.query(
+    `SELECT * FROM survivor_tournament_games
+     WHERE pool_id = $1 AND round = $2 AND winner_id IS NULL
+     ORDER BY id`,
+    [poolId, currentRound]
+  );
+
+  const games = gamesResult.rows;
+
+  if (games.length === 0) {
+    throw new Error('No unresolved games in current round');
+  }
+
+  const results = [];
+
+  for (const game of games) {
+    let winnerId;
+    let winnerName;
+
+    if (mode === 'manual' && manualResults) {
+      // Use provided results
+      const result = manualResults.find(r => r.gameId === game.id || r.espnGameId === game.espn_game_id);
+      if (result) {
+        winnerId = result.winnerId;
+        winnerName = winnerId === game.team1_id ? game.team1_name : game.team2_name;
+      } else {
+        continue; // Skip if no manual result provided
+      }
+    } else if (mode === 'chalk') {
+      // Lower seed (favorite) wins
+      winnerId = game.team1_seed <= game.team2_seed ? game.team1_id : game.team2_id;
+      winnerName = game.team1_seed <= game.team2_seed ? game.team1_name : game.team2_name;
+    } else if (mode === 'chaos') {
+      // 70% chance of upset
+      const upset = Math.random() < 0.7;
+      if (upset) {
+        winnerId = game.team1_seed > game.team2_seed ? game.team1_id : game.team2_id;
+        winnerName = game.team1_seed > game.team2_seed ? game.team1_name : game.team2_name;
+      } else {
+        winnerId = game.team1_seed <= game.team2_seed ? game.team1_id : game.team2_id;
+        winnerName = game.team1_seed <= game.team2_seed ? game.team1_name : game.team2_name;
+      }
+    } else {
+      // Random 50/50
+      const team1Wins = Math.random() < 0.5;
+      winnerId = team1Wins ? game.team1_id : game.team2_id;
+      winnerName = team1Wins ? game.team1_name : game.team2_name;
+    }
+
+    // Update game with winner
+    await pool.query(
+      `UPDATE survivor_tournament_games
+       SET winner_id = $2, status = 'final', updated_at = NOW()
+       WHERE id = $1`,
+      [game.id, winnerId]
+    );
+
+    results.push({
+      gameId: game.id,
+      matchup: `${game.team1_name} (${game.team1_seed}) vs ${game.team2_name} (${game.team2_seed})`,
+      winner: winnerName,
+      upset: (winnerId === game.team1_id && game.team1_seed > game.team2_seed) ||
+             (winnerId === game.team2_id && game.team2_seed > game.team1_seed)
+    });
+  }
+
+  return {
+    message: `Simulated ${results.length} games with mode: ${mode}`,
+    round: currentRound,
+    roundName: ROUND_NAMES[currentRound],
+    results,
+    upsets: results.filter(r => r.upset).length
+  };
+}
+
+/**
+ * Process eliminations for current round
+ * Checks all survivor picks and eliminates those who picked losing teams
+ */
+async function processEliminations(poolId) {
+  // Get current round
+  const poolResult = await pool.query(
+    'SELECT current_round FROM survivor_pools WHERE id = $1',
+    [poolId]
+  );
+
+  const currentRound = poolResult.rows[0].current_round;
+
+  // Get all games for current round that are final
+  const gamesResult = await pool.query(
+    `SELECT * FROM survivor_tournament_games
+     WHERE pool_id = $1 AND round = $2 AND status = 'final'`,
+    [poolId, currentRound]
+  );
+
+  const games = gamesResult.rows;
+  const winnerIds = new Set(games.map(g => g.winner_id));
+  const loserIds = new Set();
+
+  games.forEach(g => {
+    if (g.winner_id === g.team1_id) {
+      loserIds.add(g.team2_id);
+    } else {
+      loserIds.add(g.team1_id);
+    }
+  });
+
+  // Update survivor picks for this round
+  // Mark picks as 'won' or 'lost'
+  await pool.query(
+    `UPDATE survivor_picks sp
+     SET result = 'won', updated_at = NOW()
+     FROM survivor_entries se
+     WHERE sp.entry_id = se.id
+     AND se.pool_id = $1
+     AND sp.round = $2
+     AND sp.team_id = ANY($3::text[])`,
+    [poolId, currentRound, Array.from(winnerIds)]
+  );
+
+  await pool.query(
+    `UPDATE survivor_picks sp
+     SET result = 'lost', updated_at = NOW()
+     FROM survivor_entries se
+     WHERE sp.entry_id = se.id
+     AND se.pool_id = $1
+     AND sp.round = $2
+     AND sp.team_id = ANY($3::text[])`,
+    [poolId, currentRound, Array.from(loserIds)]
+  );
+
+  // Eliminate entries whose picks lost
+  const eliminatedResult = await pool.query(
+    `UPDATE survivor_entries se
+     SET is_alive = false, eliminated_at_round = $2, updated_at = NOW()
+     FROM survivor_picks sp
+     WHERE se.id = sp.entry_id
+     AND se.pool_id = $1
+     AND sp.round = $2
+     AND sp.result = 'lost'
+     AND se.is_alive = true
+     RETURNING se.id, se.user_id`,
+    [poolId, currentRound]
+  );
+
+  // Also eliminate entries that didn't make a pick (no-pick elimination)
+  // First, let's see who is alive and didn't pick
+  const checkNoPickers = await pool.query(
+    `SELECT se.id, se.user_id, u.username
+     FROM survivor_entries se
+     LEFT JOIN users u ON u.id = se.user_id
+     WHERE se.pool_id = $1
+     AND se.is_alive = true
+     AND NOT EXISTS (
+       SELECT 1 FROM survivor_picks sp
+       WHERE sp.entry_id = se.id AND sp.round = $2
+     )`,
+    [poolId, currentRound]
+  );
+
+  console.log(`[Survivor] Round ${currentRound}: ${checkNoPickers.rows.length} alive entries without picks:`,
+    checkNoPickers.rows.map(r => ({ entryId: r.id, userId: r.user_id, username: r.username })));
+
+  const noPickers = await pool.query(
+    `UPDATE survivor_entries se
+     SET is_alive = false, eliminated_at_round = $2, updated_at = NOW()
+     WHERE se.pool_id = $1
+     AND se.is_alive = true
+     AND NOT EXISTS (
+       SELECT 1 FROM survivor_picks sp
+       WHERE sp.entry_id = se.id AND sp.round = $2
+     )
+     RETURNING se.id, se.user_id`,
+    [poolId, currentRound]
+  );
+
+  console.log(`[Survivor] Round ${currentRound}: Eliminated ${noPickers.rowCount} entries for no-pick`);
+
+  // Get counts
+  const countResult = await pool.query(
+    `SELECT
+       (SELECT COUNT(*) FROM survivor_entries WHERE pool_id = $1 AND is_alive = true) as alive,
+       (SELECT COUNT(*) FROM survivor_entries WHERE pool_id = $1 AND is_alive = false) as eliminated,
+       (SELECT COUNT(*) FROM survivor_entries WHERE pool_id = $1) as total`,
+    [poolId]
+  );
+
+  const remainingAlive = parseInt(countResult.rows[0].alive);
+  const totalEntries = parseInt(countResult.rows[0].total);
+
+  // Check if everyone is eliminated - pool goes to house
+  if (remainingAlive === 0 && totalEntries > 0) {
+    await pool.query(
+      `UPDATE survivor_pools
+       SET status = 'complete',
+           winner_type = 'house',
+           completed_at = NOW(),
+           updated_at = NOW()
+       WHERE id = $1`,
+      [poolId]
+    );
+
+    return {
+      message: 'ALL PLAYERS ELIMINATED - Pool goes to house!',
+      round: currentRound,
+      roundName: ROUND_NAMES[currentRound],
+      eliminatedByLoss: eliminatedResult.rowCount,
+      eliminatedByNoPick: noPickers.rowCount,
+      totalEliminated: eliminatedResult.rowCount + noPickers.rowCount,
+      remainingAlive: 0,
+      allEliminated: true,
+      outcome: 'house_wins',
+      note: 'No survivors remain. The entire pot goes to the house.'
+    };
+  }
+
+  return {
+    message: 'Eliminations processed',
+    round: currentRound,
+    roundName: ROUND_NAMES[currentRound],
+    eliminatedByLoss: eliminatedResult.rowCount,
+    eliminatedByNoPick: noPickers.rowCount,
+    totalEliminated: eliminatedResult.rowCount + noPickers.rowCount,
+    remainingAlive,
+    allEliminated: false
+  };
+}
+
+/**
+ * Advance to next round
+ * Creates matchups for next round from winners
+ */
+async function advanceRound(poolId) {
+  // Get current round
+  const poolResult = await pool.query(
+    'SELECT current_round FROM survivor_pools WHERE id = $1',
+    [poolId]
+  );
+
+  const currentRound = poolResult.rows[0].current_round;
+  const nextRound = currentRound + 1;
+
+  if (nextRound > 7) {
+    // Tournament complete - survivors win!
+    // Get count of remaining survivors
+    const survivorCount = await pool.query(
+      `SELECT COUNT(*) as count FROM survivor_entries WHERE pool_id = $1 AND is_alive = true`,
+      [poolId]
+    );
+    const numSurvivors = parseInt(survivorCount.rows[0].count);
+
+    console.log(`[Survivor] Tournament complete! ${numSurvivors} survivors remaining`);
+
+    await pool.query(
+      `UPDATE survivor_pools
+       SET status = 'complete',
+           winner_type = 'survivors',
+           completed_at = NOW(),
+           updated_at = NOW()
+       WHERE id = $1`,
+      [poolId]
+    );
+
+    return {
+      message: `Tournament complete! ${numSurvivors} survivor(s) win!`,
+      status: 'complete',
+      winner_type: 'survivors',
+      survivorCount: numSurvivors
+    };
+  }
+
+  // Check if there are any games in current round
+  const currentGamesResult = await pool.query(
+    `SELECT COUNT(*) as total, COUNT(*) FILTER (WHERE status = 'final') as resolved
+     FROM survivor_tournament_games WHERE pool_id = $1 AND round = $2`,
+    [poolId, currentRound]
+  );
+
+  const totalGames = parseInt(currentGamesResult.rows[0].total);
+  const resolvedGames = parseInt(currentGamesResult.rows[0].resolved);
+
+  if (totalGames === 0) {
+    throw new Error(`No games exist for current round (${ROUND_NAMES[currentRound]}). Seed the bracket first.`);
+  }
+
+  if (resolvedGames === 0) {
+    throw new Error(`No games have been resolved in ${ROUND_NAMES[currentRound]}. Simulate the round first.`);
+  }
+
+  if (resolvedGames < totalGames) {
+    throw new Error(`Only ${resolvedGames}/${totalGames} games resolved in ${ROUND_NAMES[currentRound]}. Resolve all games before advancing.`);
+  }
+
+  // Get winners from current round
+  const winnersResult = await pool.query(
+    `SELECT * FROM survivor_tournament_games
+     WHERE pool_id = $1 AND round = $2 AND status = 'final'
+     ORDER BY region, id`,
+    [poolId, currentRound]
+  );
+
+  const winners = winnersResult.rows.map(g => ({
+    teamId: g.winner_id,
+    teamName: g.winner_id === g.team1_id ? g.team1_name : g.team2_name,
+    teamSeed: g.winner_id === g.team1_id ? g.team1_seed : g.team2_seed,
+    teamLogo: g.winner_id === g.team1_id ? g.team1_logo : g.team2_logo,
+    region: g.region
+  }));
+
+  // Create next round matchups
+  const games = [];
+
+  if (nextRound <= 5) {
+    // Regional rounds (through Elite 8)
+    for (const region of REGIONS) {
+      const regionWinners = winners.filter(w => w.region === region);
+
+      // Pair winners
+      for (let i = 0; i < regionWinners.length; i += 2) {
+        if (regionWinners[i + 1]) {
+          games.push({
+            poolId,
+            round: nextRound,
+            espnGameId: `sim-r${nextRound}-${region.toLowerCase()}-${i / 2 + 1}`,
+            region,
+            team1: regionWinners[i],
+            team2: regionWinners[i + 1]
+          });
+        }
+      }
+    }
+  } else if (nextRound === 6) {
+    // Final Four
+    // South vs East, West vs Midwest
+    const pairings = [
+      ['SOUTH', 'EAST'],
+      ['WEST', 'MIDWEST']
+    ];
+
+    console.log(`[SurvivorAdmin] Creating Final Four. Winners from Elite 8:`, winners.map(w => ({ team: w.teamName, region: w.region })));
+
+    for (let i = 0; i < pairings.length; i++) {
+      const team1 = winners.find(w => w.region === pairings[i][0]);
+      const team2 = winners.find(w => w.region === pairings[i][1]);
+
+      console.log(`[SurvivorAdmin] Final Four pairing ${i + 1}: ${pairings[i][0]} vs ${pairings[i][1]}`);
+      console.log(`[SurvivorAdmin]   Team1 (${pairings[i][0]}):`, team1 ? team1.teamName : 'NOT FOUND');
+      console.log(`[SurvivorAdmin]   Team2 (${pairings[i][1]}):`, team2 ? team2.teamName : 'NOT FOUND');
+
+      if (team1 && team2) {
+        games.push({
+          poolId,
+          round: nextRound,
+          espnGameId: `sim-ff-${i + 1}`,
+          region: 'FINAL_FOUR',
+          team1,
+          team2
+        });
+      } else {
+        console.warn(`[SurvivorAdmin] Could not create Final Four game - missing team(s)`);
+      }
+    }
+  } else if (nextRound === 7) {
+    // Championship
+    if (winners.length === 2) {
+      games.push({
+        poolId,
+        round: nextRound,
+        espnGameId: 'sim-champ',
+        region: 'CHAMPIONSHIP',
+        team1: winners[0],
+        team2: winners[1]
+      });
+    }
+  }
+
+  // Validate we have games to create
+  if (games.length === 0) {
+    throw new Error(`Failed to create matchups for ${ROUND_NAMES[nextRound]}. No valid winner pairings found.`);
+  }
+
+  // Insert new games
+  for (const game of games) {
+    await pool.query(
+      `INSERT INTO survivor_tournament_games
+       (pool_id, round, espn_game_id, region, team1_id, team1_name, team1_seed, team1_logo,
+        team2_id, team2_name, team2_seed, team2_logo, status)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, 'scheduled')`,
+      [
+        game.poolId, game.round, game.espnGameId, game.region,
+        game.team1.teamId, game.team1.teamName, game.team1.teamSeed, game.team1.teamLogo,
+        game.team2.teamId, game.team2.teamName, game.team2.teamSeed, game.team2.teamLogo
+      ]
+    );
+  }
+
+  // Update pool to next round and clear deadline
+  await pool.query(
+    `UPDATE survivor_pools
+     SET current_round = $2, round_deadline = NULL, updated_at = NOW()
+     WHERE id = $1`,
+    [poolId, nextRound]
+  );
+
+  return {
+    message: `Advanced to ${ROUND_NAMES[nextRound]}`,
+    previousRound: currentRound,
+    newRound: nextRound,
+    roundName: ROUND_NAMES[nextRound],
+    gamesCreated: games.length,
+    matchups: games.map(g => `${g.team1.teamName} vs ${g.team2.teamName}`)
+  };
+}
+
+/**
+ * Get pool admin dashboard data
+ */
+async function getPoolDashboard(poolId) {
+  // Pool info
+  const poolResult = await pool.query(
+    `SELECT * FROM survivor_pools WHERE id = $1`,
+    [poolId]
+  );
+
+  if (poolResult.rows.length === 0) {
+    throw new Error('Pool not found');
+  }
+
+  const survivorPool = poolResult.rows[0];
+
+  // Entry counts
+  const countsResult = await pool.query(
+    `SELECT
+       COUNT(*) as total,
+       COUNT(*) FILTER (WHERE is_alive = true) as alive,
+       COUNT(*) FILTER (WHERE is_alive = false) as eliminated
+     FROM survivor_entries WHERE pool_id = $1`,
+    [poolId]
+  );
+
+  // Check if bracket exists (any games at all)
+  const bracketExistsResult = await pool.query(
+    `SELECT COUNT(*) as count FROM survivor_tournament_games WHERE pool_id = $1`,
+    [poolId]
+  );
+  const hasBracket = parseInt(bracketExistsResult.rows[0].count) > 0;
+
+  // Games for current round
+  const gamesResult = await pool.query(
+    `SELECT * FROM survivor_tournament_games
+     WHERE pool_id = $1 AND round = $2
+     ORDER BY region, id`,
+    [poolId, survivorPool.current_round]
+  );
+
+  // Picks for current round
+  const picksResult = await pool.query(
+    `SELECT sp.team_id, sp.team_name, COUNT(*) as pick_count
+     FROM survivor_picks sp
+     JOIN survivor_entries se ON se.id = sp.entry_id
+     WHERE se.pool_id = $1 AND sp.round = $2
+     GROUP BY sp.team_id, sp.team_name
+     ORDER BY pick_count DESC`,
+    [poolId, survivorPool.current_round]
+  );
+
+  // Entries without picks for current round
+  const noPicks = await pool.query(
+    `SELECT COUNT(*) as count
+     FROM survivor_entries se
+     WHERE se.pool_id = $1
+     AND se.is_alive = true
+     AND NOT EXISTS (
+       SELECT 1 FROM survivor_picks sp
+       WHERE sp.entry_id = se.id AND sp.round = $2
+     )`,
+    [poolId, survivorPool.current_round]
+  );
+
+  const totalEntries = parseInt(countsResult.rows[0].total);
+  const aliveEntries = parseInt(countsResult.rows[0].alive);
+  const eliminatedEntries = parseInt(countsResult.rows[0].eliminated);
+
+  // Determine pool outcome state
+  let outcomeState = null;
+  if (survivorPool.status === 'complete') {
+    if (aliveEntries === 0 && totalEntries > 0) {
+      outcomeState = 'house_wins';
+    } else if (aliveEntries > 0) {
+      outcomeState = 'survivors_win';
+    }
+  } else if (aliveEntries === 0 && totalEntries > 0 && hasBracket) {
+    // Pool should be marked complete but hasn't been yet
+    outcomeState = 'pending_house_wins';
+  }
+
+  return {
+    pool: {
+      id: survivorPool.id,
+      name: survivorPool.name,
+      status: survivorPool.status,
+      currentRound: survivorPool.current_round,
+      roundName: hasBracket ? ROUND_NAMES[survivorPool.current_round] : 'Pre-Tournament',
+      hasBracket,
+      deadline: survivorPool.round_deadline,
+      deadlinePassed: survivorPool.round_deadline ? new Date() > new Date(survivorPool.round_deadline) : false,
+      winnerType: survivorPool.winner_type || null,
+      completedAt: survivorPool.completed_at || null
+    },
+    entries: {
+      total: totalEntries,
+      alive: aliveEntries,
+      eliminated: eliminatedEntries,
+      noPick: parseInt(noPicks.rows[0].count)
+    },
+    outcomeState,
+    currentRoundGames: gamesResult.rows.map(g => ({
+      id: g.id,
+      region: g.region,
+      team1: { id: g.team1_id, name: g.team1_name, seed: g.team1_seed, logo: g.team1_logo },
+      team2: { id: g.team2_id, name: g.team2_name, seed: g.team2_seed, logo: g.team2_logo },
+      winner: g.winner_id,
+      status: g.status
+    })),
+    pickDistribution: picksResult.rows
+  };
+}
+
+/**
+ * Reset pool to initial state
+ */
+async function resetPool(poolId, options = {}) {
+  const { deleteEntries = false } = options;
+
+  // Delete all games
+  await pool.query('DELETE FROM survivor_tournament_games WHERE pool_id = $1', [poolId]);
+
+  // Delete all picks
+  await pool.query(
+    `DELETE FROM survivor_picks sp
+     USING survivor_entries se
+     WHERE sp.entry_id = se.id AND se.pool_id = $1`,
+    [poolId]
+  );
+
+  if (deleteEntries) {
+    // Full reset: delete all entries
+    await pool.query('DELETE FROM survivor_entries WHERE pool_id = $1', [poolId]);
+  } else {
+    // Soft reset: just reset entries to alive
+    await pool.query(
+      `UPDATE survivor_entries
+       SET is_alive = true, eliminated_at_round = NULL, updated_at = NOW()
+       WHERE pool_id = $1`,
+      [poolId]
+    );
+  }
+
+  // Reset pool
+  await pool.query(
+    `UPDATE survivor_pools
+     SET status = 'open', current_round = 1, round_deadline = NULL, updated_at = NOW()
+     WHERE id = $1`,
+    [poolId]
+  );
+
+  const message = deleteEntries
+    ? 'Pool fully reset (all entries deleted)'
+    : 'Pool reset to initial state (entries kept)';
+
+  return { message, entriesDeleted: deleteEntries };
+}
+
+module.exports = {
+  getAllTeams,
+  generateRandomBracket,
+  setManualBracket,
+  setDeadline,
+  clearDeadline,
+  simulateRound,
+  processEliminations,
+  advanceRound,
+  getPoolDashboard,
+  resetPool,
+  ROUND_NAMES
+};