dubs-server 1.0.0

package/routes/sportsRoutes.js

@@ -0,0 +1,1271 @@
+const express = require('express');
+const router = express.Router();
+const axios = require('axios');
+const theSportsDB = require('thesportsdb');
+
+// Set the API key
+const API_KEY = '819154';
+theSportsDB.setApiKey(API_KEY);
+
+// League IDs for our sports
+const LEAGUE_IDS = {
+  NBA: 4387,
+  NHL: 4380,
+  MLB: 4424,
+  NFL: 4391,
+  EPL: 4328,
+  UFC: 4443,
+  NCAAF: 4479,  // NCAA Division 1 College Football
+  NCAAB: 4607   // NCAA Division I Basketball Mens
+};
+
+// ESPN Rankings URLs
+const ESPN_RANKINGS_URLS = {
+  NCAAF: 'http://site.api.espn.com/apis/site/v2/sports/football/college-football/rankings',
+  NCAAB: 'http://site.api.espn.com/apis/site/v2/sports/basketball/mens-college-basketball/rankings'
+};
+
+/**
+ * @route   GET /api/sports/leagues
+ * @desc    Get all available leagues
+ * @access  Public
+ */
+router.get('/leagues', async (req, res) => {
+  try {
+    const data = await theSportsDB.getLeagueList();
+    res.json({ success: true, data });
+  } catch (error) {
+    console.error('Error fetching leagues:', error);
+    res.status(500).json({ success: false, error: 'Failed to fetch leagues' });
+  }
+});
+
+/**
+ * @route   GET /api/sports/league/:id
+ * @desc    Get details for a specific league
+ * @access  Public
+ */
+router.get('/league/:id', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const data = await theSportsDB.getLeagueDetailsById(id);
+    res.json({ success: true, data });
+  } catch (error) {
+    console.error(`Error fetching league ${req.params.id}:`, error);
+    res.status(500).json({ success: false, error: 'Failed to fetch league details' });
+  }
+});
+
+/**
+ * @route   GET /api/sports/teams/:league
+ * @desc    Get teams for a specific league (NBA, NHL, MLB)
+ * @access  Public
+ */
+router.get('/teams/:league', async (req, res) => {
+  try {
+    const { league } = req.params;
+    const leagueId = LEAGUE_IDS[league.toUpperCase()];
+    
+    if (!leagueId) {
+      return res.status(400).json({
+        success: false,
+        error: 'Invalid league. Please use NBA, NHL, MLB, NFL, EPL, UFC, NCAAF, or NCAAB.'
+      });
+    }
+    
+    // Get league details first to get the league name
+    const leagueDetails = await theSportsDB.getLeagueDetailsById(leagueId);
+    if (!leagueDetails.leagues || leagueDetails.leagues.length === 0) {
+      return res.status(404).json({ success: false, error: 'League not found' });
+    }
+    
+    const leagueName = leagueDetails.leagues[0].strLeague;
+    const teams = await theSportsDB.getTeamsByLeagueName(leagueName);
+    
+    res.json({ success: true, data: teams });
+  } catch (error) {
+    console.error(`Error fetching teams for ${req.params.league}:`, error);
+    res.status(500).json({ success: false, error: 'Failed to fetch teams' });
+  }
+});
+
+/**
+ * ═══════════════════════════════════════════════════════════════════════════
+ * 🥊 UFC STUB EVENTS - ISOLATED DATA SOURCE
+ * ═══════════════════════════════════════════════════════════════════════════
+ * TheSportsDB has unreliable/empty UFC data, so we maintain curated stub data.
+ * This function is completely isolated from other sports data sources.
+ *
+ * To update UFC events:
+ * 1. Add new events to the array below
+ * 2. Upload fighter images to S3 (dubs-avatars-prod/UFC/)
+ * 3. Update strHomeTeamBadge and strAwayTeamBadge URLs
+ *
+ * Structure matches TheSportsDB format exactly for oracle compatibility.
+ * ═══════════════════════════════════════════════════════════════════════════
+ */
+function getUFCStubEvents() {
+  // Filter out events that have already passed
+  const now = new Date();
+
+  const allEvents = [];
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // 🧪 MOCK UFC EVENT - Development Testing (dynamic date, 5 min from now)
+  // ═══════════════════════════════════════════════════════════════════════
+  if (process.env.NODE_ENV === 'development') {
+    const startTime = new Date(now.getTime() + 5 * 60000); // 5 minutes from now
+    const formattedDate = startTime.toISOString().split('T')[0];
+    const formattedTime = startTime.toISOString().split('T')[1].substring(0, 8);
+    const timestamp = `${formattedDate}T${formattedTime}`;
+
+    allEvents.push({
+      "idEvent": "mock-ufc-gaethje-pimblett",
+      "idAPIfootball": null,
+      "strEvent": "Justin Gaethje vs Paddy Pimblett",
+      "strEventAlternate": "[MOCK] UFC 324: Gaethje vs. Pimblett",
+      "strFilename": `UFC ${formattedDate} UFC 324 Gaethje vs Pimblett`,
+      "strSport": "Fighting",
+      "idLeague": "4443",
+      "strLeague": "UFC",
+      "strLeagueBadge": "https://a.espncdn.com/i/teamlogos/leagues/500/ufc.png",
+      "strSeason": "2026",
+      "strDescriptionEN": "[MOCK EVENT] UFC 324 Main Event - Lightweight bout",
+      "strHomeTeam": "Justin Gaethje",
+      "strAwayTeam": "Paddy Pimblett",
+      "intHomeScore": null,
+      "intRound": "1",
+      "intAwayScore": null,
+      "intSpectators": null,
+      "strOfficial": null,
+      "strTimestamp": timestamp,
+      "dateEvent": formattedDate,
+      "dateEventLocal": formattedDate,
+      "strTime": formattedTime,
+      "strTimeLocal": formattedTime,
+      "strGroup": "Main Card",
+      "idHomeTeam": "3022345",
+      "strHomeTeamBadge": "https://dubs-avatars-prod.s3.us-east-2.amazonaws.com/UFC/justin_gaethje.png",
+      "idAwayTeam": "4008549",
+      "strAwayTeamBadge": "https://dubs-avatars-prod.s3.us-east-2.amazonaws.com/UFC/paddy_pimblett.png",
+      "intScore": null,
+      "intScoreVotes": null,
+      "strResult": "",
+      "idVenue": "16132",
+      "strVenue": "T-Mobile Arena",
+      "strCountry": "United States",
+      "strCity": "Las Vegas, NV",
+      "strPoster": "https://dubs-avatars-prod.s3.us-east-2.amazonaws.com/UFC/Cards/gaethje_pimblett.png",
+      "strSquare": "https://dubs-avatars-prod.s3.us-east-2.amazonaws.com/UFC/Cards/gaethje_pimblett.png",
+      "strFanart": "",
+      "strThumb": "",
+      "strBanner": "",
+      "strMap": "",
+      "strTweet1": "",
+      "strVideo": "",
+      "strStatus": "Not Started",
+      "strPostponed": "no",
+      "strLocked": "unlocked"
+    });
+
+    console.log(`[UFC] Added mock event for ${formattedDate} at ${formattedTime}`);
+  }
+
+  // Real UFC events (will be filtered out if in the past)
+  allEvents.push({
+    "idEvent": "2389036",
+    "idAPIfootball": null,
+    "strEvent": "Justin Gaethje vs Paddy Pimblett",
+    "strEventAlternate": "UFC 324: Gaethje vs. Pimblett",
+    "strFilename": "UFC 2026-01-24 UFC 324 Gaethje vs Pimblett",
+    "strSport": "Fighting",
+    "idLeague": "4443",
+    "strLeague": "UFC",
+    "strLeagueBadge": "https://a.espncdn.com/i/teamlogos/leagues/500/ufc.png",
+    "strSeason": "2026",
+    "strDescriptionEN": "UFC 324 Main Event - Lightweight bout",
+    "strHomeTeam": "Justin Gaethje",
+    "strAwayTeam": "Paddy Pimblett",
+    "intHomeScore": null,
+    "intRound": "1",
+    "intAwayScore": null,
+    "intSpectators": null,
+    "strOfficial": null,
+    "strTimestamp": "2026-01-25T02:00:00",
+    "dateEvent": "2026-01-25",
+    "dateEventLocal": "2026-01-24",
+    "strTime": "02:00:00",
+    "strTimeLocal": "21:00:00",
+    "strGroup": "Main Card",
+    "idHomeTeam": "3022345",
+    "strHomeTeamBadge": "https://dubs-avatars-prod.s3.us-east-2.amazonaws.com/UFC/justin_gaethje.png",
+    "idAwayTeam": "4008549",
+    "strAwayTeamBadge": "https://dubs-avatars-prod.s3.us-east-2.amazonaws.com/UFC/paddy_pimblett.png",
+    "intScore": null,
+    "intScoreVotes": null,
+    "strResult": "",
+    "idVenue": "16132",
+    "strVenue": "T-Mobile Arena",
+    "strCountry": "United States",
+    "strCity": "Las Vegas, NV",
+    "strPoster": "https://dubs-avatars-prod.s3.us-east-2.amazonaws.com/UFC/Cards/gaethje_pimblett.png",
+    "strSquare": "https://dubs-avatars-prod.s3.us-east-2.amazonaws.com/UFC/Cards/gaethje_pimblett.png",
+    "strFanart": "",
+    "strThumb": "",
+    "strBanner": "",
+    "strMap": "",
+    "strTweet1": "",
+    "strVideo": "",
+    "strStatus": "Not Started",
+    "strPostponed": "no",
+    "strLocked": "unlocked"
+  });
+
+  allEvents.push({
+      "idEvent": "2389037",
+      "idAPIfootball": null,
+      "strEvent": "Alexander Volkanovski vs Diego Lopes",
+      "strEventAlternate": "UFC 325: Volkanovski vs Lopes 2",
+      "strFilename": "UFC 2026-01-31 UFC 325 Volkanovski vs Lopes 2",
+      "strSport": "Fighting",
+      "idLeague": "4443",
+      "strLeague": "UFC",
+      "strLeagueBadge": "https://a.espncdn.com/i/teamlogos/leagues/500/ufc.png",
+      "strSeason": "2026",
+      "strDescriptionEN": "UFC 325 Main Event - Featherweight bout",
+      "strHomeTeam": "Alexander Volkanovski",
+      "strAwayTeam": "Diego Lopes",
+      "intHomeScore": null,
+      "intRound": "2",
+      "intAwayScore": null,
+      "intSpectators": null,
+      "strOfficial": null,
+      "strTimestamp": "2026-02-01T02:00:00",
+      "dateEvent": "2026-02-01",
+      "dateEventLocal": "2026-02-01",
+      "strTime": "02:00:00",
+      "strTimeLocal": "13:00:00",
+      "strGroup": "Main Card",
+      "idHomeTeam": null,
+      "strHomeTeamBadge": "https://dubs-avatars-prod.s3.us-east-2.amazonaws.com/UFC/alexander_volkanovski.png",
+      "idAwayTeam": null,
+      "strAwayTeamBadge": "https://dubs-avatars-prod.s3.us-east-2.amazonaws.com/UFC/deigo_lopes.png",
+      "intScore": null,
+      "intScoreVotes": null,
+      "strResult": "",
+      "idVenue": "29731",
+      "strVenue": "Qudos Bank Arena",
+      "strCountry": "Australia",
+      "strCity": "Sydney, NSW",
+      "strPoster": "https://dubs-avatars-prod.s3.us-east-2.amazonaws.com/UFC/Cards/volkanovski_lopes.png",
+      "strSquare": "https://dubs-avatars-prod.s3.us-east-2.amazonaws.com/UFC/Cards/volkanovski_lopes.png",
+      "strFanart": "",
+      "strThumb": "",
+      "strBanner": "",
+      "strMap": "",
+      "strTweet1": "",
+      "strVideo": "",
+      "strStatus": "Not Started",
+      "strPostponed": "no",
+      "strLocked": "unlocked"
+    });
+
+  allEvents.push({
+      "idEvent": "2391879",
+      "idAPIfootball": null,
+      "strEvent": "Mario Bautista vs Vinicius Oliveira",
+      "strEventAlternate": "UFC Fight Night: Bautista vs Oliveira",
+      "strFilename": "UFC 2026-02-07 UFC Fight Night 266 Bautista vs Oliveira",
+      "strSport": "Fighting",
+      "idLeague": "4443",
+      "strLeague": "UFC",
+      "strLeagueBadge": "https://a.espncdn.com/i/teamlogos/leagues/500/ufc.png",
+      "strSeason": "2026",
+      "strDescriptionEN": "UFC Fight Night Main Event - Bantamweight bout",
+      "strHomeTeam": "Mario Bautista",
+      "strAwayTeam": "Vinicius Oliveira",
+      "intHomeScore": null,
+      "intRound": "3",
+      "intAwayScore": null,
+      "intSpectators": null,
+      "strOfficial": null,
+      "strTimestamp": "2026-02-08T02:00:00",
+      "dateEvent": "2026-02-08",
+      "dateEventLocal": "2026-02-07",
+      "strTime": "02:00:00",
+      "strTimeLocal": "21:00:00",
+      "strGroup": "Main Card",
+      "idHomeTeam": null,
+      "strHomeTeamBadge": "https://dubs-avatars-prod.s3.us-east-2.amazonaws.com/UFC/mario_bautista.png",
+      "idAwayTeam": null,
+      "strAwayTeamBadge": "https://dubs-avatars-prod.s3.us-east-2.amazonaws.com/UFC/vinicius_oliveira.png",
+      "intScore": null,
+      "intScoreVotes": null,
+      "strResult": "",
+      "idVenue": "18567",
+      "strVenue": "UFC APEX",
+      "strCountry": "United States",
+      "strCity": "Las Vegas, Nevada",
+      "strPoster": "https://dubs-avatars-prod.s3.us-east-2.amazonaws.com/UFC/Cards/bautista_oliveira.png",
+      "strSquare": "https://dubs-avatars-prod.s3.us-east-2.amazonaws.com/UFC/Cards/bautista_oliveira.png",
+      "strFanart": "",
+      "strThumb": "",
+      "strBanner": "",
+      "strMap": "",
+      "strTweet1": "",
+      "strVideo": "",
+      "strStatus": "Not Started",
+      "strPostponed": "no",
+      "strLocked": "unlocked"
+    });
+
+  // Return only future events (filter out past events), sorted by date (soonest first)
+  return allEvents
+    .filter(event => {
+      const eventDate = new Date(event.strTimestamp + 'Z');
+      return eventDate > now;
+    })
+    .sort((a, b) => {
+      const dateA = new Date(a.strTimestamp + 'Z');
+      const dateB = new Date(b.strTimestamp + 'Z');
+      return dateA.getTime() - dateB.getTime();
+    });
+}
+
+/**
+ * ═══════════════════════════════════════════════════════════════════════════
+ * 🏀 NCAAB EVENTS - ESPN DATA SOURCE
+ * ═══════════════════════════════════════════════════════════════════════════
+ * TheSportsDB has unreliable NCAAB data (placeholder times, missing games),
+ * so we fetch from ESPN and transform to TheSportsDB format.
+ * ═══════════════════════════════════════════════════════════════════════════
+ */
+async function getNCAABEventsFromESPN() {
+  const events = [];
+  const now = new Date();
+
+  // Query ESPN for the next 7 days
+  for (let i = 0; i < 7; i++) {
+    const date = new Date(now);
+    date.setDate(date.getDate() + i);
+    const dateStr = date.toISOString().split('T')[0].replace(/-/g, ''); // YYYYMMDD
+
+    try {
+      const response = await axios.get(
+        `https://site.api.espn.com/apis/site/v2/sports/basketball/mens-college-basketball/scoreboard?dates=${dateStr}`
+      );
+
+      if (response.data?.events) {
+        for (const game of response.data.events) {
+          // Only include scheduled games (not finished or in progress)
+          if (game.status?.type?.name !== 'STATUS_SCHEDULED') continue;
+
+          // Extract home and away teams
+          const homeTeam = game.competitions?.[0]?.competitors?.find(c => c.homeAway === 'home');
+          const awayTeam = game.competitions?.[0]?.competitors?.find(c => c.homeAway === 'away');
+
+          if (!homeTeam || !awayTeam) continue;
+
+          // Parse ESPN date (already has Z) and convert to TheSportsDB format
+          const gameDate = new Date(game.date);
+          const dateEvent = gameDate.toISOString().split('T')[0];
+          const strTime = gameDate.toISOString().split('T')[1].substring(0, 8);
+          const strTimestamp = `${dateEvent}T${strTime}`;
+
+          // Transform to TheSportsDB format
+          events.push({
+            idEvent: `espn-ncaab-${game.id}`,
+            strEvent: `${homeTeam.team.displayName} vs ${awayTeam.team.displayName}`,
+            strEventAlternate: game.name,
+            strSport: "Basketball",
+            idLeague: "4607",
+            strLeague: "NCAAB",
+            strLeagueBadge: "https://a.espncdn.com/i/teamlogos/ncaa/500/ncaa.png",
+            strSeason: "2025-2026",
+            strHomeTeam: homeTeam.team.displayName,
+            strAwayTeam: awayTeam.team.displayName,
+            intHomeScore: null,
+            intAwayScore: null,
+            strTimestamp: strTimestamp,
+            dateEvent: dateEvent,
+            strTime: strTime,
+            idHomeTeam: homeTeam.team.id,
+            strHomeTeamBadge: homeTeam.team.logo,
+            idAwayTeam: awayTeam.team.id,
+            strAwayTeamBadge: awayTeam.team.logo,
+            strVenue: game.competitions?.[0]?.venue?.fullName || "",
+            strCity: game.competitions?.[0]?.venue?.address?.city || "",
+            strStatus: "NS",
+            strPostponed: "no",
+            strLocked: "unlocked"
+          });
+        }
+      }
+    } catch (error) {
+      console.error(`[NCAAB ESPN] Error fetching games for ${dateStr}:`, error.message);
+    }
+  }
+
+  // Sort by date (soonest first)
+  events.sort((a, b) => {
+    const dateA = new Date(a.strTimestamp + 'Z');
+    const dateB = new Date(b.strTimestamp + 'Z');
+    return dateA.getTime() - dateB.getTime();
+  });
+
+  console.log(`[NCAAB ESPN] Fetched ${events.length} upcoming games`);
+  return events;
+}
+
+/**
+ * ═══════════════════════════════════════════════════════════════════════════
+ * 🥊 UFC EVENT ID MAPPING - BACKWARD COMPATIBILITY
+ * ═══════════════════════════════════════════════════════════════════════════
+ * Maps fighter combinations to original stub event IDs to maintain backward
+ * compatibility with existing bets. The frontend matches bets by idEvent,
+ * so we must preserve these IDs for events that already have bets.
+ *
+ * Key format: "homeTeam|awayTeam" (lowercase, trimmed)
+ * ═══════════════════════════════════════════════════════════════════════════
+ */
+const UFC_EVENT_ID_MAP = {
+  'mario bautista|vinicius oliveira': '2391879',
+};
+
+/**
+ * Gets the original event ID for a UFC fight if it exists in our mapping
+ */
+function getOriginalUFCEventId(homeTeam, awayTeam) {
+  const key = `${homeTeam.toLowerCase().trim()}|${awayTeam.toLowerCase().trim()}`;
+  return UFC_EVENT_ID_MAP[key] || null;
+}
+
+/**
+ * ═══════════════════════════════════════════════════════════════════════════
+ * 🥊 UFC EVENTS FROM ESPN
+ * ═══════════════════════════════════════════════════════════════════════════
+ * Fetch real UFC events from ESPN and transform to TheSportsDB format.
+ * ESPN provides scheduled fights with athlete IDs that we can use to construct
+ * headshot URLs using the pattern:
+ * https://a.espncdn.com/combiner/i?img=/i/headshots/mma/players/full/{id}.png
+ * ═══════════════════════════════════════════════════════════════════════════
+ */
+async function getUFCEventsFromESPN() {
+  const events = [];
+  const now = new Date();
+
+  try {
+    // Query ESPN for UFC events in the next 60 days
+    const startDate = now.toISOString().split('T')[0].replace(/-/g, '');
+    const endDate = new Date(now.getTime() + 60 * 24 * 60 * 60 * 1000)
+      .toISOString().split('T')[0].replace(/-/g, '');
+
+    const response = await axios.get(
+      `https://site.api.espn.com/apis/site/v2/sports/mma/ufc/scoreboard?dates=${startDate}-${endDate}`
+    );
+
+    if (response.data?.events) {
+      for (const card of response.data.events) {
+        // Get the main event (usually the last competition on the card)
+        const competitions = card.competitions || [];
+        if (competitions.length === 0) continue;
+
+        // Main event is the last fight on the card
+        const mainEvent = competitions[competitions.length - 1];
+        const competitors = mainEvent.competitors || [];
+        if (competitors.length < 2) continue;
+
+        // Find red corner (order 1) and blue corner (order 2)
+        const fighter1 = competitors.find(c => c.order === 1) || competitors[0];
+        const fighter2 = competitors.find(c => c.order === 2) || competitors[1];
+
+        // Construct headshot URLs from athlete IDs
+        const getHeadshotUrl = (athleteId) => {
+          if (!athleteId) return null;
+          return `https://a.espncdn.com/combiner/i?img=/i/headshots/mma/players/full/${athleteId}.png&w=350&h=254`;
+        };
+
+        // Parse date - use mainEvent.date (main card time) instead of card.date (prelims)
+        const eventDate = new Date(mainEvent.date || card.date);
+        const dateEvent = eventDate.toISOString().split('T')[0];
+        const strTime = eventDate.toISOString().split('T')[1].substring(0, 8);
+        const strTimestamp = `${dateEvent}T${strTime}`;
+
+        // Get venue info
+        const venue = mainEvent.venue || card.venues?.[0] || {};
+
+        // Weight class / fight type
+        const weightClass = mainEvent.type?.abbreviation || "Main Event";
+
+        // Check if this fight has an existing event ID (for backward compatibility with bets)
+        const homeTeam = fighter1.athlete?.fullName || 'TBA';
+        const awayTeam = fighter2.athlete?.fullName || 'TBA';
+        const originalEventId = getOriginalUFCEventId(homeTeam, awayTeam);
+        const eventId = originalEventId || `espn-ufc-${card.id}`;
+
+        events.push({
+          idEvent: eventId,
+          strEvent: `${homeTeam} vs ${awayTeam}`,
+          strEventAlternate: card.name,
+          strFilename: `UFC ${dateEvent} ${card.shortName || card.name}`,
+          strSport: "Fighting",
+          idLeague: "4443",
+          strLeague: "UFC",
+          strLeagueBadge: "https://a.espncdn.com/i/teamlogos/leagues/500/ufc.png",
+          strSeason: eventDate.getFullYear().toString(),
+          strDescriptionEN: `${card.name} - ${weightClass}`,
+          strHomeTeam: homeTeam,
+          strAwayTeam: awayTeam,
+          intHomeScore: null,
+          intAwayScore: null,
+          strTimestamp: strTimestamp,
+          dateEvent: dateEvent,
+          strTime: strTime,
+          strGroup: "Main Card",
+          idHomeTeam: fighter1.id,
+          strHomeTeamBadge: getHeadshotUrl(fighter1.id),
+          idAwayTeam: fighter2.id,
+          strAwayTeamBadge: getHeadshotUrl(fighter2.id),
+          strVenue: venue.fullName || "TBA",
+          strCountry: venue.address?.country || "",
+          strCity: venue.address?.city ? `${venue.address.city}, ${venue.address.state || ''}` : "",
+          strPoster: null, // ESPN doesn't provide card posters
+          strSquare: null,
+          strStatus: "NS",
+          strPostponed: "no",
+          strLocked: "unlocked",
+          // Extra ESPN data
+          espnEventId: card.id,
+          weightClass: weightClass,
+          fighterRecords: {
+            home: fighter1.records?.[0]?.summary || "",
+            away: fighter2.records?.[0]?.summary || ""
+          }
+        });
+      }
+    }
+  } catch (error) {
+    console.error(`[UFC ESPN] Error fetching events:`, error.message);
+  }
+
+  // Sort by date (soonest first)
+  events.sort((a, b) => {
+    const dateA = new Date(a.strTimestamp + 'Z');
+    const dateB = new Date(b.strTimestamp + 'Z');
+    return dateA.getTime() - dateB.getTime();
+  });
+
+  console.log(`[UFC ESPN] Fetched ${events.length} upcoming events`);
+  return events;
+}
+
+router.get('/events/:league', async (req, res) => {
+  try {
+    const { league } = req.params;
+    const leagueId = LEAGUE_IDS[league.toUpperCase()];
+
+    if (!leagueId) {
+      return res.status(400).json({
+        success: false,
+        error: 'Invalid league. Please use NBA, NHL, MLB, NFL, EPL, UFC, NCAAF, or NCAAB.'
+      });
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // 🥊 UFC EVENTS - ESPN DATA SOURCE
+    // ═══════════════════════════════════════════════════════════════════════
+    // Fetch real UFC events from ESPN with fighter headshots.
+    // Falls back to stub data if ESPN fails or returns no events.
+    // ═══════════════════════════════════════════════════════════════════════
+    if (league.toUpperCase() === 'UFC') {
+      let ufcEvents = await getUFCEventsFromESPN();
+
+      // Add mock event in development (for testing)
+      // Uses real fighter names/IDs so headshots work and oracle can resolve
+      if (process.env.NODE_ENV === 'development') {
+        const now = new Date();
+        const startTime = new Date(now.getTime() + 5 * 60000); // 5 minutes from now
+        const formattedDate = startTime.toISOString().split('T')[0];
+        const formattedTime = startTime.toISOString().split('T')[1].substring(0, 8);
+        const timestamp = `${formattedDate}T${formattedTime}`;
+
+        ufcEvents.unshift({
+          idEvent: "mock-ufc-dev-test",
+          strEvent: "Mario Bautista vs Vinicius Oliveira",
+          strEventAlternate: "[MOCK] UFC Fight Night: Bautista vs Oliveira",
+          strSport: "Fighting",
+          idLeague: "4443",
+          strLeague: "UFC",
+          strLeagueBadge: "https://a.espncdn.com/i/teamlogos/leagues/500/ufc.png",
+          strSeason: "2026",
+          strDescriptionEN: "[MOCK EVENT] Development testing - Bantamweight bout",
+          strHomeTeam: "Mario Bautista",
+          strAwayTeam: "Vinicius Oliveira",
+          intHomeScore: null,
+          intAwayScore: null,
+          strTimestamp: timestamp,
+          dateEvent: formattedDate,
+          strTime: formattedTime,
+          strGroup: "Main Card",
+          idHomeTeam: "4410868",
+          strHomeTeamBadge: "https://a.espncdn.com/combiner/i?img=/i/headshots/mma/players/full/4410868.png&w=350&h=254",
+          idAwayTeam: "4884877",
+          strAwayTeamBadge: "https://a.espncdn.com/combiner/i?img=/i/headshots/mma/players/full/4884877.png&w=350&h=254",
+          strVenue: "UFC APEX",
+          strCountry: "United States",
+          strCity: "Las Vegas, NV",
+          strStatus: "NS",
+          strPostponed: "no",
+          strLocked: "unlocked"
+        });
+        console.log(`[UFC] Added mock event for development testing`);
+      }
+
+      // Fall back to stub data if ESPN returns no events
+      if (ufcEvents.length === 0) {
+        console.log(`[UFC] No ESPN events, falling back to stub data`);
+        ufcEvents = getUFCStubEvents();
+      }
+
+      return res.json({ success: true, data: { events: ufcEvents } });
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // 🏀 NCAAB EVENTS - ESPN DATA SOURCE
+    // ═══════════════════════════════════════════════════════════════════════
+    // TheSportsDB has unreliable NCAAB data (placeholder times, missing games),
+    // so we fetch from ESPN and transform to TheSportsDB format.
+    // ═══════════════════════════════════════════════════════════════════════
+    if (league.toUpperCase() === 'NCAAB') {
+      const ncaabEvents = await getNCAABEventsFromESPN();
+
+      // Add mock event in development
+      if (process.env.NODE_ENV === 'development') {
+        const now = new Date();
+        const startTime = new Date(now.getTime() + 5 * 60000);
+        const formattedDate = startTime.toISOString().split('T')[0];
+        const formattedTime = startTime.toISOString().split('T')[1].substring(0, 8);
+        const timestamp = `${formattedDate}T${formattedTime}`;
+
+        ncaabEvents.unshift({
+          idEvent: "mock-ncaab-duke-unc-123",
+          strEvent: "Duke vs North Carolina",
+          strEventAlternate: "North Carolina @ Duke",
+          strSport: "Basketball",
+          idLeague: "4607",
+          strLeague: "NCAAB",
+          strLeagueBadge: "https://a.espncdn.com/i/teamlogos/ncaa/500/ncaa.png",
+          strSeason: "2025-2026",
+          strDescriptionEN: "[MOCK EVENT] Tobacco Road Rivalry",
+          strHomeTeam: "Duke",
+          strAwayTeam: "North Carolina",
+          intHomeScore: null,
+          intAwayScore: null,
+          strTimestamp: timestamp,
+          dateEvent: formattedDate,
+          strTime: formattedTime,
+          idHomeTeam: "150",
+          strHomeTeamBadge: "https://a.espncdn.com/i/teamlogos/ncaa/500/150.png",
+          idAwayTeam: "153",
+          strAwayTeamBadge: "https://a.espncdn.com/i/teamlogos/ncaa/500/153.png",
+          strVenue: "Cameron Indoor Stadium",
+          strCity: "Durham, NC",
+          strStatus: "NS",
+          strPostponed: "no",
+          strLocked: "unlocked"
+        });
+      }
+
+      return res.json({ success: true, data: { events: ncaabEvents } });
+    }
+
+    const config = {
+      method: 'get',
+      maxBodyLength: Infinity,
+      url: `https://www.thesportsdb.com/api/v1/json/${API_KEY}/eventsnextleague.php?id=${leagueId}`,
+      headers: { }
+    };
+
+    const response = await axios.request(config);
+    
+    // Add mock NBA event in development environment
+    if (process.env.NODE_ENV === 'development' && league.toUpperCase() === 'NBA') {
+      // If events array doesn't exist, create it
+      if (!response.data.events) {
+        response.data.events = [];
+      }
+      
+      // Get current date for base
+      const today = new Date();
+      
+      // Set time to current time + 2 minutes
+      const startTime = new Date(today.getTime() + 5 * 60000);
+      
+      // Format date and time properly
+      const formattedDate = startTime.toISOString().split('T')[0]; // YYYY-MM-DD format
+      const formattedTime = startTime.toISOString().split('T')[1].substring(0, 8); // HH:MM:SS format
+      const timestamp = `${formattedDate}T${formattedTime}`;
+      
+      // Create a simple mock NBA event
+      const mockNBAEvent = {
+        idEvent: "mock-123456",
+        idAPIfootball: "mock-415061",
+        strEvent: "Adam vs. Amy",
+        strEventAlternate: "Amy @ Adams",
+        strFilename: `NBA ${formattedDate} Philadelphia 76ers vs Chicago Bulls`,
+        strSport: "Basketball",
+        idLeague: "4387",
+        strLeague: "NBA",
+        strLeagueBadge: "https://www.thesportsdb.com/images/media/league/badge/frdjqy1536585083.png",
+        strSeason: "2024-2025",
+        strDescriptionEN: "[MOCK EVENT] This is a mock event for development purposes.",
+        strHomeTeam: "Adam",
+        strAwayTeam: "Amy",
+        intHomeScore: null,
+        intRound: "0",
+        intAwayScore: null,
+        intSpectators: null,
+        strOfficial: null,
+        strTimestamp: timestamp,
+        dateEvent: formattedDate,
+        dateEventLocal: formattedDate,
+        strTime: formattedTime,
+        strTimeLocal: formattedTime,
+        strGroup: "",
+        idHomeTeam: "134863",
+        strHomeTeamBadge: "https://dubs-api-dev-f14bd1509129.herokuapp.com/images/adam.png",
+        idAwayTeam: "134870",
+        strAwayTeamBadge: "https://dubs-api-dev-f14bd1509129.herokuapp.com/images/amy.png",
+        intScore: null,
+        intScoreVotes: null,
+        strResult: "",
+        idVenue: "19333",
+        strVenue: "Wells Fargo Center",
+        strCountry: "United States",
+        strCity: "",
+        strPoster: "https://r2.thesportsdb.com/images/media/event/poster/omiq4k1738097128.jpg",
+        strSquare: "",
+        strFanart: null,
+        strThumb: "https://r2.thesportsdb.com/images/media/event/thumb/yl7lte1728123518.jpg",
+        strBanner: "",
+        strMap: null,
+        strTweet1: "",
+        strTweet2: "",
+        strTweet3: "",
+        strVideo: "",
+        strStatus: "NS",
+        strPostponed: "no",
+        strLocked: "unlocked"
+      };
+      
+      // Add mock event to the beginning of the array
+      response.data.events.unshift(mockNBAEvent);
+    }
+
+    // Add mock EPL event in development environment (for testing draw betting)
+    if (process.env.NODE_ENV === 'development' && league.toUpperCase() === 'EPL') {
+      // If events array doesn't exist, create it
+      if (!response.data.events) {
+        response.data.events = [];
+      }
+
+      // Get current date for base
+      const today = new Date();
+
+      // Set time to current time + 5 minutes
+      const startTime = new Date(today.getTime() + 5 * 60000);
+
+      // Format date and time properly
+      const formattedDate = startTime.toISOString().split('T')[0];
+      const formattedTime = startTime.toISOString().split('T')[1].substring(0, 8);
+      const timestamp = `${formattedDate}T${formattedTime}`;
+
+      // Create a mock EPL event (Chelsea @ Arsenal - will end in draw)
+      const mockEPLEvent = {
+        idEvent: "mock-epl-draw-123",
+        idAPIfootball: "mock-epl-415061",
+        strEvent: "Arsenal vs Chelsea",
+        strEventAlternate: "Chelsea @ Arsenal",
+        strFilename: `EPL ${formattedDate} Arsenal vs Chelsea`,
+        strSport: "Soccer",
+        idLeague: "4328",
+        strLeague: "English Premier League",
+        strLeagueBadge: "https://www.thesportsdb.com/images/media/league/badge/i6o0kh1549879062.png",
+        strSeason: "2024-2025",
+        strDescriptionEN: "[MOCK EVENT] Draw test - This game will end 1-1 for testing draw betting.",
+        strHomeTeam: "Arsenal",
+        strAwayTeam: "Chelsea",
+        intHomeScore: null,
+        intRound: "0",
+        intAwayScore: null,
+        intSpectators: null,
+        strOfficial: null,
+        strTimestamp: timestamp,
+        dateEvent: formattedDate,
+        dateEventLocal: formattedDate,
+        strTime: formattedTime,
+        strTimeLocal: formattedTime,
+        strGroup: "",
+        idHomeTeam: "133604",
+        strHomeTeamBadge: "https://www.thesportsdb.com/images/media/team/badge/uyhbfe1612467038.png",
+        idAwayTeam: "133610",
+        strAwayTeamBadge: "https://www.thesportsdb.com/images/media/team/badge/fbb0lh1617619204.png",
+        intScore: null,
+        intScoreVotes: null,
+        strResult: "",
+        idVenue: "12345",
+        strVenue: "Emirates Stadium",
+        strCountry: "England",
+        strCity: "London",
+        strPoster: "",
+        strSquare: "",
+        strFanart: null,
+        strThumb: "",
+        strBanner: "",
+        strMap: null,
+        strTweet1: "",
+        strTweet2: "",
+        strTweet3: "",
+        strVideo: "",
+        strStatus: "NS",
+        strPostponed: "no",
+        strLocked: "unlocked"
+      };
+
+      // Add mock EPL event to the beginning of the array
+      response.data.events.unshift(mockEPLEvent);
+    }
+
+    // Add mock NCAAF event in development environment
+    if (process.env.NODE_ENV === 'development' && league.toUpperCase() === 'NCAAF') {
+      // If events array doesn't exist, create it
+      if (!response.data.events) {
+        response.data.events = [];
+      }
+
+      // Get current date for base
+      const today = new Date();
+
+      // Set time to current time + 5 minutes
+      const startTime = new Date(today.getTime() + 5 * 60000);
+
+      // Format date and time properly
+      const formattedDate = startTime.toISOString().split('T')[0];
+      const formattedTime = startTime.toISOString().split('T')[1].substring(0, 8);
+      const timestamp = `${formattedDate}T${formattedTime}`;
+
+      // Create a mock NCAAF event (Ohio State @ Michigan)
+      const mockNCAAFEvent = {
+        idEvent: "mock-ncaaf-osu-mich-123",
+        idAPIfootball: "mock-ncaaf-415061",
+        strEvent: "Ohio State vs Michigan",
+        strEventAlternate: "Michigan @ Ohio State",
+        strFilename: `NCAAF ${formattedDate} Ohio State vs Michigan`,
+        strSport: "American Football",
+        idLeague: "4479",
+        strLeague: "NCAA Division 1",
+        strLeagueAlternate: "NCAA Football",
+        strLeagueBadge: "https://a.espncdn.com/i/teamlogos/ncaa/500/ncaa.png",
+        strSeason: "2025-2026",
+        strDescriptionEN: "[MOCK EVENT] The Game - Classic Big Ten rivalry matchup",
+        strHomeTeam: "Ohio State",
+        strAwayTeam: "Michigan",
+        intHomeScore: null,
+        intRound: "0",
+        intAwayScore: null,
+        intSpectators: null,
+        strOfficial: null,
+        strTimestamp: timestamp,
+        dateEvent: formattedDate,
+        dateEventLocal: formattedDate,
+        strTime: formattedTime,
+        strTimeLocal: formattedTime,
+        strGroup: "",
+        idHomeTeam: "4522",
+        strHomeTeamBadge: "https://a.espncdn.com/i/teamlogos/ncaa/500/194.png",
+        idAwayTeam: "4523",
+        strAwayTeamBadge: "https://a.espncdn.com/i/teamlogos/ncaa/500/130.png",
+        intScore: null,
+        intScoreVotes: null,
+        strResult: "",
+        idVenue: "3856",
+        strVenue: "Ohio Stadium",
+        strCountry: "United States",
+        strCity: "Columbus, OH",
+        strPoster: "",
+        strSquare: "",
+        strFanart: null,
+        strThumb: "",
+        strBanner: "",
+        strMap: null,
+        strTweet1: "",
+        strTweet2: "",
+        strTweet3: "",
+        strVideo: "",
+        strStatus: "NS",
+        strPostponed: "no",
+        strLocked: "unlocked"
+      };
+
+      // Add mock NCAAF event to the beginning of the array
+      response.data.events.unshift(mockNCAAFEvent);
+    }
+
+    res.json({ success: true, data: response.data });
+  } catch (error) {
+    console.error(`Error fetching events for ${req.params.league}:`, error);
+    res.status(500).json({ success: false, error: 'Failed to fetch events' });
+  }
+});
+
+/**
+ * @route   GET /api/sports/ncaab/teams
+ * @desc    Get all NCAAB teams with pagination (from ESPN)
+ * @access  Public
+ * @query   page - Page number (default: 1)
+ * @query   limit - Items per page (default: 25, max: 100)
+ */
+router.get('/ncaab/teams', async (req, res) => {
+  try {
+    const page = Math.max(1, parseInt(req.query.page) || 1);
+    const limit = Math.min(100, Math.max(1, parseInt(req.query.limit) || 25));
+
+    const response = await axios.get('http://site.api.espn.com/apis/site/v2/sports/basketball/mens-college-basketball/teams');
+
+    // ESPN returns teams nested under sports[0].leagues[0].teams
+    const leagueData = response.data?.sports?.[0]?.leagues?.[0];
+    const rawTeams = leagueData?.teams || [];
+
+    // Extract team objects (ESPN wraps each in a { team: {...} } object)
+    const allTeams = rawTeams.map(item => {
+      const team = item.team || item;
+      return {
+        id: team.id,
+        name: team.displayName,
+        shortName: team.shortDisplayName,
+        nickname: team.nickname,
+        abbreviation: team.abbreviation,
+        location: team.location,
+        color: team.color,
+        alternateColor: team.alternateColor,
+        logo: team.logos?.[0]?.href || null,
+        isActive: team.isActive
+      };
+    });
+
+    // Calculate pagination
+    const totalTeams = allTeams.length;
+    const totalPages = Math.ceil(totalTeams / limit);
+    const startIndex = (page - 1) * limit;
+    const endIndex = startIndex + limit;
+    const paginatedTeams = allTeams.slice(startIndex, endIndex);
+
+    res.json({
+      success: true,
+      data: {
+        teams: paginatedTeams,
+        pagination: {
+          page,
+          limit,
+          totalTeams,
+          totalPages,
+          hasNextPage: page < totalPages,
+          hasPrevPage: page > 1
+        }
+      }
+    });
+  } catch (error) {
+    console.error('Error fetching NCAAB teams:', error);
+    res.status(500).json({ success: false, error: 'Failed to fetch NCAAB teams' });
+  }
+});
+
+/**
+ * @route   GET /api/sports/ncaab/conferences
+ * @desc    Get all NCAAB conferences with their teams (from ESPN)
+ * @access  Public
+ * @query   includeTeams - Include teams in each conference (default: false)
+ */
+router.get('/ncaab/conferences', async (req, res) => {
+  try {
+    const includeTeams = req.query.includeTeams === 'true';
+
+    const response = await axios.get('http://site.api.espn.com/apis/site/v2/sports/basketball/mens-college-basketball/groups');
+
+    // ESPN returns conferences nested under groups[0].children
+    const topLevelGroups = response.data?.groups || [];
+    const conferences = [];
+
+    for (const group of topLevelGroups) {
+      const children = group.children || [];
+      for (const conf of children) {
+        const conferenceData = {
+          id: conf.id,
+          name: conf.name,
+          abbreviation: conf.abbreviation,
+          teamCount: conf.teams?.length || 0
+        };
+
+        if (includeTeams && conf.teams) {
+          conferenceData.teams = conf.teams.map(team => ({
+            id: team.id,
+            name: team.displayName,
+            shortName: team.shortDisplayName,
+            nickname: team.name,
+            abbreviation: team.abbreviation,
+            logo: team.logos?.[0]?.href || null
+          }));
+        }
+
+        conferences.push(conferenceData);
+      }
+    }
+
+    // Sort conferences alphabetically by name
+    conferences.sort((a, b) => a.name.localeCompare(b.name));
+
+    res.json({
+      success: true,
+      data: {
+        conferences,
+        totalConferences: conferences.length
+      }
+    });
+  } catch (error) {
+    console.error('Error fetching NCAAB conferences:', error);
+    res.status(500).json({ success: false, error: 'Failed to fetch NCAAB conferences' });
+  }
+});
+
+/**
+ * @route   GET /api/sports/ncaab/standings
+ * @desc    Get NCAAB standings by conference (from ESPN)
+ * @access  Public
+ * @query   conference - Filter by conference abbreviation (e.g., 'acc', 'big12')
+ */
+router.get('/ncaab/standings', async (req, res) => {
+  try {
+    const conferenceFilter = req.query.conference?.toLowerCase();
+
+    const response = await axios.get('http://site.api.espn.com/apis/v2/sports/basketball/mens-college-basketball/standings');
+
+    // ESPN returns standings grouped by conference under children array
+    const division = response.data;
+    const conferenceStandings = division?.children || [];
+
+    // Helper to extract stat value by name
+    const getStatValue = (stats, name) => {
+      const stat = stats?.find(s => s.name === name || s.abbreviation === name);
+      return stat?.displayValue || stat?.value || null;
+    };
+
+    const standings = [];
+
+    for (const conf of conferenceStandings) {
+      // Skip if filtering by conference and this isn't it
+      if (conferenceFilter && conf.abbreviation?.toLowerCase() !== conferenceFilter) {
+        continue;
+      }
+
+      const conferenceData = {
+        id: conf.id,
+        name: conf.name,
+        abbreviation: conf.abbreviation,
+        teams: []
+      };
+
+      // Get standings entries (teams)
+      const entries = conf.standings?.entries || [];
+
+      for (const entry of entries) {
+        const team = entry.team || {};
+        const stats = entry.stats || [];
+
+        conferenceData.teams.push({
+          id: team.id,
+          name: team.displayName,
+          shortName: team.shortDisplayName,
+          abbreviation: team.abbreviation,
+          logo: team.logos?.[0]?.href || null,
+          stats: {
+            wins: getStatValue(stats, 'wins'),
+            losses: getStatValue(stats, 'losses'),
+            winPercent: getStatValue(stats, 'winPercent'),
+            conferenceWins: getStatValue(stats, 'leagueWinPercent'),
+            pointsFor: getStatValue(stats, 'pointsFor'),
+            pointsAgainst: getStatValue(stats, 'pointsAgainst'),
+            pointDifferential: getStatValue(stats, 'pointDifferential'),
+            streak: getStatValue(stats, 'streak'),
+            playoffSeed: getStatValue(stats, 'playoffSeed')
+          }
+        });
+      }
+
+      // Sort teams by wins descending, then by win percentage
+      conferenceData.teams.sort((a, b) => {
+        const winsA = parseInt(a.stats.wins) || 0;
+        const winsB = parseInt(b.stats.wins) || 0;
+        if (winsB !== winsA) return winsB - winsA;
+        const pctA = parseFloat(a.stats.winPercent) || 0;
+        const pctB = parseFloat(b.stats.winPercent) || 0;
+        return pctB - pctA;
+      });
+
+      standings.push(conferenceData);
+    }
+
+    // Sort conferences alphabetically
+    standings.sort((a, b) => a.name.localeCompare(b.name));
+
+    res.json({
+      success: true,
+      data: {
+        standings,
+        totalConferences: standings.length
+      }
+    });
+  } catch (error) {
+    console.error('Error fetching NCAAB standings:', error);
+    res.status(500).json({ success: false, error: 'Failed to fetch NCAAB standings' });
+  }
+});
+
+/**
+ * @route   GET /api/sports/rankings/:league
+ * @desc    Get AP Top 25 rankings for NCAAF or NCAAB
+ * @access  Public
+ * @query   limit - Number of teams to return (default: 25, max: 25)
+ */
+router.get('/rankings/:league', async (req, res) => {
+  try {
+    const { league } = req.params;
+    const leagueUpper = league.toUpperCase();
+    const url = ESPN_RANKINGS_URLS[leagueUpper];
+
+    if (!url) {
+      return res.status(400).json({
+        success: false,
+        error: 'Invalid league. Rankings are available for NCAAF and NCAAB only.'
+      });
+    }
+
+    const limit = Math.min(25, Math.max(1, parseInt(req.query.limit) || 25));
+
+    const response = await axios.get(url);
+    const rankingsData = response.data.rankings || [];
+
+    // Find AP Top 25 ranking (type: 'ap')
+    const apRanking = rankingsData.find(r => r.type === 'ap') || rankingsData[0];
+
+    if (!apRanking) {
+      return res.status(404).json({
+        success: false,
+        error: 'No rankings data available'
+      });
+    }
+
+    const ranks = (apRanking.ranks || []).slice(0, limit);
+    const others = apRanking.others || [];
+
+    // Transform to a cleaner format
+    const transformedRanks = ranks.map(rank => ({
+      rank: rank.current,
+      previousRank: rank.previous,
+      trend: rank.trend,
+      points: rank.points,
+      firstPlaceVotes: rank.firstPlaceVotes,
+      record: rank.recordSummary,
+      team: {
+        id: rank.team?.id,
+        name: rank.team?.name || rank.team?.location,
+        nickname: rank.team?.nickname,
+        abbreviation: rank.team?.abbreviation,
+        location: rank.team?.location,
+        logo: rank.team?.logos?.[0]?.href || null,
+        color: rank.team?.color,
+        alternateColor: rank.team?.alternateColor
+      }
+    }));
+
+    const transformedOthers = others.map(rank => ({
+      points: rank.points,
+      trend: rank.trend,
+      record: rank.recordSummary,
+      team: {
+        id: rank.team?.id,
+        name: rank.team?.name || rank.team?.location,
+        nickname: rank.team?.nickname,
+        abbreviation: rank.team?.abbreviation,
+        location: rank.team?.location,
+        logo: rank.team?.logos?.[0]?.href || null
+      }
+    }));
+
+    res.json({
+      success: true,
+      data: {
+        name: apRanking.name,
+        type: apRanking.type,
+        season: apRanking.season?.year,
+        lastUpdated: apRanking.date,
+        ranks: transformedRanks,
+        othersReceivingVotes: transformedOthers
+      }
+    });
+  } catch (error) {
+    console.error(`Error fetching rankings for ${req.params.league}:`, error);
+    res.status(500).json({ success: false, error: 'Failed to fetch rankings' });
+  }
+});
+
+/**
+ * @route   GET /api/sports/standings/:league/:season
+ * @desc    Get standings for a specific league and season
+ * @access  Public
+ */
+router.get('/standings/:league/:season', async (req, res) => {
+  try {
+    const { league, season } = req.params;
+    const leagueId = LEAGUE_IDS[league.toUpperCase()];
+    
+    if (!leagueId) {
+      return res.status(400).json({
+        success: false,
+        error: 'Invalid league. Please use NBA, NHL, MLB, NFL, EPL, UFC, NCAAF, or NCAAB.'
+      });
+    }
+    
+    const data = await theSportsDB.getLookupTableByLeagueIdAndSeason(leagueId, season);
+    res.json({ success: true, data });
+  } catch (error) {
+    console.error(`Error fetching standings for ${req.params.league}:`, error);
+    res.status(500).json({ success: false, error: 'Failed to fetch standings' });
+  }
+});
+
+/**
+ * @route   GET /api/sports/seasons/:league
+ * @desc    Get available seasons for a league
+ * @access  Public
+ */
+router.get('/seasons/:league', async (req, res) => {
+  try {
+    const { league } = req.params;
+    const leagueId = LEAGUE_IDS[league.toUpperCase()];
+    
+    if (!leagueId) {
+      return res.status(400).json({
+        success: false,
+        error: 'Invalid league. Please use NBA, NHL, MLB, NFL, EPL, UFC, NCAAF, or NCAAB.'
+      });
+    }
+    
+    const data = await theSportsDB.getSeasonsInLeagueById(leagueId);
+    res.json({ success: true, data });
+  } catch (error) {
+    console.error(`Error fetching seasons for ${req.params.league}:`, error);
+    res.status(500).json({ success: false, error: 'Failed to fetch seasons' });
+  }
+});
+
+module.exports = router;