dubs-server 1.0.0

package/services/survivorSimulator.js

@@ -0,0 +1,475 @@
+/**
+ * Survivor Pool Simulator Service
+ * Development/testing tools for March Madness Survivor Pool
+ *
+ * Provides mock tournament data and simulation controls for testing
+ * without waiting for actual tournament games.
+ */
+
+const { pool } = require('./db');
+const survivorController = require('../controllers/survivorController');
+
+// ============================================
+// MOCK TOURNAMENT DATA
+// ============================================
+
+// ESPN logo URL helper - uses ESPN's CDN
+const espnLogo = (espnId) => `https://a.espncdn.com/i/teamlogos/ncaa/500/${espnId}.png`;
+
+// 68 teams for March Madness (64 + 4 First Four) with ESPN team IDs for logos
+const MOCK_TEAMS = [
+  // EAST Region
+  { id: 'e1', name: 'Duke', seed: 1, region: 'EAST', logo: espnLogo(150) },
+  { id: 'e2', name: 'Alabama', seed: 2, region: 'EAST', logo: espnLogo(333) },
+  { id: 'e3', name: 'Wisconsin', seed: 3, region: 'EAST', logo: espnLogo(275) },
+  { id: 'e4', name: 'Arizona', seed: 4, region: 'EAST', logo: espnLogo(12) },
+  { id: 'e5', name: 'Oregon', seed: 5, region: 'EAST', logo: espnLogo(2483) },
+  { id: 'e6', name: 'BYU', seed: 6, region: 'EAST', logo: espnLogo(252) },
+  { id: 'e7', name: 'St. Marys', seed: 7, region: 'EAST', logo: espnLogo(2608) },
+  { id: 'e8', name: 'Louisville', seed: 8, region: 'EAST', logo: espnLogo(97) },
+  { id: 'e9', name: 'Creighton', seed: 9, region: 'EAST', logo: espnLogo(156) },
+  { id: 'e10', name: 'Colorado', seed: 10, region: 'EAST', logo: espnLogo(38) },
+  { id: 'e11', name: 'Memphis', seed: 11, region: 'EAST', logo: espnLogo(235) },
+  { id: 'e12', name: 'UC San Diego', seed: 12, region: 'EAST', logo: espnLogo(301) },
+  { id: 'e13', name: 'Yale', seed: 13, region: 'EAST', logo: espnLogo(43) },
+  { id: 'e14', name: 'Lipscomb', seed: 14, region: 'EAST', logo: espnLogo(288) },
+  { id: 'e15', name: 'Robert Morris', seed: 15, region: 'EAST', logo: espnLogo(2523) },
+  { id: 'e16', name: 'American', seed: 16, region: 'EAST', logo: espnLogo(44) },
+
+  // WEST Region
+  { id: 'w1', name: 'Florida', seed: 1, region: 'WEST', logo: espnLogo(57) },
+  { id: 'w2', name: 'St. Johns', seed: 2, region: 'WEST', logo: espnLogo(2599) },
+  { id: 'w3', name: 'Texas Tech', seed: 3, region: 'WEST', logo: espnLogo(2641) },
+  { id: 'w4', name: 'Maryland', seed: 4, region: 'WEST', logo: espnLogo(120) },
+  { id: 'w5', name: 'Memphis State', seed: 5, region: 'WEST', logo: espnLogo(235) },
+  { id: 'w6', name: 'Missouri', seed: 6, region: 'WEST', logo: espnLogo(142) },
+  { id: 'w7', name: 'Kansas', seed: 7, region: 'WEST', logo: espnLogo(2305) },
+  { id: 'w8', name: 'UConn', seed: 8, region: 'WEST', logo: espnLogo(41) },
+  { id: 'w9', name: 'Oklahoma', seed: 9, region: 'WEST', logo: espnLogo(201) },
+  { id: 'w10', name: 'Arkansas', seed: 10, region: 'WEST', logo: espnLogo(8) },
+  { id: 'w11', name: 'Drake', seed: 11, region: 'WEST', logo: espnLogo(2181) },
+  { id: 'w12', name: 'Grand Canyon', seed: 12, region: 'WEST', logo: espnLogo(2253) },
+  { id: 'w13', name: 'UNC Wilmington', seed: 13, region: 'WEST', logo: espnLogo(350) },
+  { id: 'w14', name: 'North Dakota', seed: 14, region: 'WEST', logo: espnLogo(155) },
+  { id: 'w15', name: 'Omaha', seed: 15, region: 'WEST', logo: espnLogo(2437) },
+  { id: 'w16', name: 'Norfolk State', seed: 16, region: 'WEST', logo: espnLogo(2450) },
+
+  // SOUTH Region
+  { id: 's1', name: 'Auburn', seed: 1, region: 'SOUTH', logo: espnLogo(2) },
+  { id: 's2', name: 'Michigan State', seed: 2, region: 'SOUTH', logo: espnLogo(127) },
+  { id: 's3', name: 'Iowa State', seed: 3, region: 'SOUTH', logo: espnLogo(66) },
+  { id: 's4', name: 'Texas A&M', seed: 4, region: 'SOUTH', logo: espnLogo(245) },
+  { id: 's5', name: 'Michigan', seed: 5, region: 'SOUTH', logo: espnLogo(130) },
+  { id: 's6', name: 'Ole Miss', seed: 6, region: 'SOUTH', logo: espnLogo(145) },
+  { id: 's7', name: 'Marquette', seed: 7, region: 'SOUTH', logo: espnLogo(269) },
+  { id: 's8', name: 'Boise State', seed: 8, region: 'SOUTH', logo: espnLogo(68) },
+  { id: 's9', name: 'Georgia', seed: 9, region: 'SOUTH', logo: espnLogo(61) },
+  { id: 's10', name: 'New Mexico', seed: 10, region: 'SOUTH', logo: espnLogo(167) },
+  { id: 's11', name: 'Vanderbilt', seed: 11, region: 'SOUTH', logo: espnLogo(238) },
+  { id: 's12', name: 'Liberty', seed: 12, region: 'SOUTH', logo: espnLogo(2335) },
+  { id: 's13', name: 'Akron', seed: 13, region: 'SOUTH', logo: espnLogo(2006) },
+  { id: 's14', name: 'Montana', seed: 14, region: 'SOUTH', logo: espnLogo(149) },
+  { id: 's15', name: 'Wofford', seed: 15, region: 'SOUTH', logo: espnLogo(2747) },
+  { id: 's16', name: 'Alabama State', seed: 16, region: 'SOUTH', logo: espnLogo(2011) },
+
+  // MIDWEST Region
+  { id: 'm1', name: 'Houston', seed: 1, region: 'MIDWEST', logo: espnLogo(248) },
+  { id: 'm2', name: 'Tennessee', seed: 2, region: 'MIDWEST', logo: espnLogo(2633) },
+  { id: 'm3', name: 'Kentucky', seed: 3, region: 'MIDWEST', logo: espnLogo(96) },
+  { id: 'm4', name: 'Purdue', seed: 4, region: 'MIDWEST', logo: espnLogo(2509) },
+  { id: 'm5', name: 'Clemson', seed: 5, region: 'MIDWEST', logo: espnLogo(228) },
+  { id: 'm6', name: 'Illinois', seed: 6, region: 'MIDWEST', logo: espnLogo(356) },
+  { id: 'm7', name: 'UCLA', seed: 7, region: 'MIDWEST', logo: espnLogo(26) },
+  { id: 'm8', name: 'Gonzaga', seed: 8, region: 'MIDWEST', logo: espnLogo(2250) },
+  { id: 'm9', name: 'Baylor', seed: 9, region: 'MIDWEST', logo: espnLogo(239) },
+  { id: 'm10', name: 'Texas', seed: 10, region: 'MIDWEST', logo: espnLogo(251) },
+  { id: 'm11', name: 'NC State', seed: 11, region: 'MIDWEST', logo: espnLogo(152) },
+  { id: 'm12', name: 'McNeese State', seed: 12, region: 'MIDWEST', logo: espnLogo(2377) },
+  { id: 'm13', name: 'Vermont', seed: 13, region: 'MIDWEST', logo: espnLogo(261) },
+  { id: 'm14', name: 'Troy', seed: 14, region: 'MIDWEST', logo: espnLogo(2653) },
+  { id: 'm15', name: 'Siena', seed: 15, region: 'MIDWEST', logo: espnLogo(2561) },
+  { id: 'm16', name: 'SFA', seed: 16, region: 'MIDWEST', logo: espnLogo(2617) },
+
+  // First Four teams (play-in games)
+  { id: 'ff1', name: 'Texas Southern', seed: 16, region: 'FIRST_FOUR', logo: espnLogo(2640) },
+  { id: 'ff2', name: 'Jackson State', seed: 16, region: 'FIRST_FOUR', logo: espnLogo(2296) },
+  { id: 'ff3', name: 'Wagner', seed: 16, region: 'FIRST_FOUR', logo: espnLogo(2718) },
+  { id: 'ff4', name: 'Bryant', seed: 16, region: 'FIRST_FOUR', logo: espnLogo(2803) },
+];
+
+// Generate mock bracket with standard seeding matchups
+function generateMockBracket(poolId) {
+  const games = [];
+  let gameIndex = 0;
+
+  // Helper to create game object
+  const createGame = (team1, team2, round, region) => ({
+    round,
+    espnGameId: `mock-${poolId}-${++gameIndex}`,
+    gameDate: new Date(Date.now() + (round * 2 + gameIndex) * 3600000), // Stagger games
+    team1Id: team1.id,
+    team1Name: team1.name,
+    team1Seed: team1.seed,
+    team1Logo: team1.logo || null,
+    team2Id: team2.id,
+    team2Name: team2.name,
+    team2Seed: team2.seed,
+    team2Logo: team2.logo || null,
+    region,
+    status: 'scheduled'
+  });
+
+  // Round 1: First Four (4 games)
+  const firstFourTeams = MOCK_TEAMS.filter(t => t.region === 'FIRST_FOUR');
+  for (let i = 0; i < firstFourTeams.length; i += 2) {
+    games.push(createGame(firstFourTeams[i], firstFourTeams[i + 1], 1, 'FIRST_FOUR'));
+  }
+
+  // Round 2: Round of 64 (32 games - standard 1v16, 2v15, etc.)
+  const regions = ['EAST', 'WEST', 'SOUTH', 'MIDWEST'];
+  for (const region of regions) {
+    const regionTeams = MOCK_TEAMS.filter(t => t.region === region);
+    // Standard bracket: 1v16, 8v9, 5v12, 4v13, 6v11, 3v14, 7v10, 2v15
+    const matchups = [
+      [1, 16], [8, 9], [5, 12], [4, 13], [6, 11], [3, 14], [7, 10], [2, 15]
+    ];
+    for (const [seed1, seed2] of matchups) {
+      const team1 = regionTeams.find(t => t.seed === seed1);
+      const team2 = regionTeams.find(t => t.seed === seed2);
+      if (team1 && team2) {
+        games.push(createGame(team1, team2, 2, region));
+      }
+    }
+  }
+
+  // Note: Rounds 3-7 will be generated dynamically based on Round 2 winners
+  // For simulation purposes, we'll generate placeholder games
+
+  return games;
+}
+
+class SurvivorSimulator {
+  /**
+   * Generate mock tournament games for a pool
+   */
+  async generateTournamentBracket(poolId) {
+    const games = generateMockBracket(poolId);
+    const imported = await survivorController.importTournamentGames(poolId, games);
+
+    console.log(`[Simulator] Generated ${imported.length} tournament games for pool ${poolId}`);
+    return imported;
+  }
+
+  /**
+   * Simulate a round with configurable upset chance
+   * @param {number} poolId - Pool ID
+   * @param {object} options - Simulation options
+   * @param {number} options.upsetChance - Probability of upset (0-1, default 0.2)
+   * @param {boolean} options.favorChalk - If true, favorites always win
+   */
+  async simulateRound(poolId, options = {}) {
+    const { upsetChance = 0.2, favorChalk = false } = options;
+
+    // Get 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];
+    const currentRound = survivorPool.current_round;
+
+    // Get unresolved games for current round
+    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;
+    console.log(`[Simulator] Simulating ${games.length} games for round ${currentRound}`);
+
+    const results = [];
+
+    for (const game of games) {
+      // Determine winner based on seed and upset chance
+      const team1Seed = game.team1_seed || 8;
+      const team2Seed = game.team2_seed || 8;
+      const team1Favored = team1Seed < team2Seed;
+
+      let winnerId;
+      let winnerName;
+
+      if (favorChalk) {
+        // Chalk: favorite always wins
+        winnerId = team1Favored ? game.team1_id : game.team2_id;
+        winnerName = team1Favored ? game.team1_name : game.team2_name;
+      } else {
+        // Random with upset chance
+        const isUpset = Math.random() < upsetChance;
+        if (team1Favored) {
+          winnerId = isUpset ? game.team2_id : game.team1_id;
+          winnerName = isUpset ? game.team2_name : game.team1_name;
+        } else {
+          winnerId = isUpset ? game.team1_id : game.team2_id;
+          winnerName = isUpset ? game.team1_name : game.team2_name;
+        }
+      }
+
+      // Generate realistic scores
+      const baseScore = 65 + Math.floor(Math.random() * 25);
+      const margin = Math.floor(Math.random() * 20) + 3;
+      const winnerScore = baseScore + Math.floor(margin / 2);
+      const loserScore = baseScore - Math.floor(margin / 2);
+
+      const team1Score = winnerId === game.team1_id ? winnerScore : loserScore;
+      const team2Score = winnerId === game.team2_id ? winnerScore : loserScore;
+
+      // Update game result
+      await pool.query(
+        `UPDATE survivor_tournament_games
+         SET winner_id = $3, team1_score = $4, team2_score = $5, status = 'final', updated_at = NOW()
+         WHERE pool_id = $1 AND id = $2`,
+        [poolId, game.id, winnerId, team1Score, team2Score]
+      );
+
+      results.push({
+        gameId: game.id,
+        espnGameId: game.espn_game_id,
+        winner: winnerName,
+        team1Score,
+        team2Score,
+        isUpset: (team1Favored && winnerId === game.team2_id) || (!team1Favored && winnerId === game.team1_id)
+      });
+
+      console.log(`   ${game.team1_name} (${team1Seed}) vs ${game.team2_name} (${team2Seed}): ${winnerName} wins ${team1Score}-${team2Score}`);
+    }
+
+    // Now resolve the round: process picks, eliminate losers, and advance to next round
+    console.log(`[Simulator] Resolving round ${currentRound}...`);
+    const survivorOracle = require('./survivorOracle');
+    const resolution = await survivorOracle.resolveCurrentRound(poolId);
+
+    return {
+      poolId,
+      round: currentRound,
+      gamesSimulated: results.length,
+      results,
+      resolution
+    };
+  }
+
+  /**
+   * Generate test entries with random picks for current round
+   */
+  async generateTestEntries(poolId, count = 10) {
+    // Get pool
+    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];
+
+    // Get available teams for current round
+    const gamesResult = await pool.query(
+      `SELECT * FROM survivor_tournament_games
+       WHERE pool_id = $1 AND round = $2`,
+      [poolId, survivorPool.current_round]
+    );
+
+    const teams = [];
+    for (const game of gamesResult.rows) {
+      teams.push({
+        id: game.team1_id,
+        name: game.team1_name,
+        seed: game.team1_seed,
+        espnGameId: game.espn_game_id,
+        opponent: game.team2_name
+      });
+      teams.push({
+        id: game.team2_id,
+        name: game.team2_name,
+        seed: game.team2_seed,
+        espnGameId: game.espn_game_id,
+        opponent: game.team1_name
+      });
+    }
+
+    const entries = [];
+
+    for (let i = 0; i < count; i++) {
+      // Create test user if needed
+      const walletAddress = `TestWallet${Date.now()}${i}`;
+      const username = `TestUser${i + 1}`;
+
+      const userResult = await pool.query(
+        `INSERT INTO users (wallet_address, username)
+         VALUES ($1, $2)
+         ON CONFLICT (wallet_address) DO UPDATE SET username = EXCLUDED.username
+         RETURNING id`,
+        [walletAddress, username]
+      );
+      const userId = userResult.rows[0].id;
+
+      // Join pool
+      const entryResult = await pool.query(
+        `INSERT INTO survivor_entries (pool_id, user_id, wallet_address)
+         VALUES ($1, $2, $3)
+         ON CONFLICT (pool_id, user_id) DO NOTHING
+         RETURNING *`,
+        [poolId, userId, walletAddress]
+      );
+
+      if (entryResult.rows.length === 0) {
+        continue; // Already joined
+      }
+
+      const entry = entryResult.rows[0];
+
+      // Pick random team
+      const randomTeam = teams[Math.floor(Math.random() * teams.length)];
+
+      await pool.query(
+        `INSERT INTO survivor_picks
+         (entry_id, round, team_id, team_name, team_seed, espn_game_id, opponent_name)
+         VALUES ($1, $2, $3, $4, $5, $6, $7)`,
+        [entry.id, survivorPool.current_round, randomTeam.id, randomTeam.name, randomTeam.seed, randomTeam.espnGameId, randomTeam.opponent]
+      );
+
+      entries.push({
+        ...entry,
+        username,
+        pick: randomTeam.name
+      });
+
+      console.log(`[Simulator] Created entry: ${username} picked ${randomTeam.name}`);
+    }
+
+    return {
+      poolId,
+      entriesCreated: entries.length,
+      entries
+    };
+  }
+
+  /**
+   * Set round deadline to N minutes from now
+   */
+  async 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]
+    );
+
+    console.log(`[Simulator] Set deadline for pool ${poolId} to ${deadline.toISOString()}`);
+    return { poolId, deadline };
+  }
+
+  /**
+   * Reset pool to round 1 and clear all entries/picks
+   * @param {number} poolId - Pool ID
+   * @param {object} options - Reset options
+   * @param {boolean} options.deleteEntries - If true, also delete all entries (full reset)
+   */
+  async resetPool(poolId, options = {}) {
+    const { deleteEntries = false } = options;
+    const client = await pool.connect();
+
+    try {
+      await client.query('BEGIN');
+
+      // Delete all picks
+      await client.query(
+        `DELETE FROM survivor_picks WHERE entry_id IN (SELECT id FROM survivor_entries WHERE pool_id = $1)`,
+        [poolId]
+      );
+
+      if (deleteEntries) {
+        // Full reset: delete all entries
+        await client.query(
+          `DELETE FROM survivor_entries WHERE pool_id = $1`,
+          [poolId]
+        );
+        console.log(`[Simulator] Deleted all entries for pool ${poolId}`);
+      } else {
+        // Soft reset: just reset entries to alive
+        await client.query(
+          `UPDATE survivor_entries
+           SET is_alive = true, eliminated_at_round = NULL, updated_at = NOW()
+           WHERE pool_id = $1`,
+          [poolId]
+        );
+      }
+
+      // Delete tournament games (so bracket can be regenerated fresh)
+      await client.query(
+        `DELETE FROM survivor_tournament_games WHERE pool_id = $1`,
+        [poolId]
+      );
+
+      // Reset pool to round 1 and open status
+      await client.query(
+        `UPDATE survivor_pools
+         SET current_round = 1, round_deadline = NULL, status = 'open', updated_at = NOW()
+         WHERE id = $1`,
+        [poolId]
+      );
+
+      await client.query('COMMIT');
+
+      const message = deleteEntries
+        ? 'Pool fully reset (entries deleted)'
+        : 'Pool reset to round 1 (entries kept)';
+      console.log(`[Simulator] ${message}`);
+      return { poolId, message, entriesDeleted: deleteEntries };
+    } catch (error) {
+      await client.query('ROLLBACK');
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+
+  /**
+   * Activate pool and set to round 2 (skip First Four)
+   */
+  async activatePool(poolId) {
+    await pool.query(
+      `UPDATE survivor_pools SET status = 'active', current_round = 2, updated_at = NOW() WHERE id = $1`,
+      [poolId]
+    );
+
+    console.log(`[Simulator] Pool ${poolId} activated at round 2`);
+    return { poolId, status: 'active', currentRound: 2 };
+  }
+
+  /**
+   * Delete test entries (cleanup)
+   */
+  async deleteTestEntries(poolId) {
+    const result = await pool.query(
+      `DELETE FROM survivor_entries
+       WHERE pool_id = $1 AND wallet_address LIKE 'TestWallet%'
+       RETURNING id`,
+      [poolId]
+    );
+
+    console.log(`[Simulator] Deleted ${result.rowCount} test entries from pool ${poolId}`);
+    return { poolId, deletedCount: result.rowCount };
+  }
+}
+
+module.exports = new SurvivorSimulator();
+module.exports.SurvivorSimulator = SurvivorSimulator;
+module.exports.MOCK_TEAMS = MOCK_TEAMS;