buildpath/match_collector/index.ts

const api_key = process.env.RIOT_API_KEY
const sleep_minutes = 12

import { MongoClient } from 'mongodb'

import champion_stat from './champion_stat'
import { Match } from './api'

// Region configuration: platform -> regional routing value
const PLATFORMS: Record<string, string> = {
  EUW1: 'EUROPE',
  EUN1: 'EUROPE',
  NA1: 'AMERICAS',
  KR: 'ASIA'
}

function getPlatformBaseUrl(platform: string): string {
  return `https://${platform.toLowerCase()}.api.riotgames.com`
}

function getRegionalBaseUrl(region: string): string {
  return `https://${region.toLowerCase()}.api.riotgames.com`
}

main()

async function main() {
  // Check if we're in development mode with pre-loaded data
  if (process.env.NODE_ENV === 'development' && process.env.USE_IMPORTED_DATA === 'true') {
    console.log('MatchCollector - Development mode with pre-loaded data')
    await runWithPreloadedData()
    return
  }

  // Original production mode
  console.log('MatchCollector - Hello !')
  const client = await connectToDatabase()
  const [latestPatch, latestPatchTime] = await fetchLatestPatchDate(client)
  console.log(
    'Connected to database, latest patch ' + latestPatch + ' was epoch: ' + latestPatchTime
  )

  console.log('Using RIOT_API_KEY: ' + api_key)
  if (api_key != null && api_key != undefined && api_key != '') {
    // Iterate through all platforms
    for (const [platform, region] of Object.entries(PLATFORMS)) {
      console.log(`\n=== Processing platform: ${platform} (region: ${region}) ===`)

      const alreadySeenGameList = await alreadySeenGames(client, latestPatch, platform)
      console.log(
        'We already have ' + alreadySeenGameList.length + ' matches for this patch/platform !'
      )

      const challengerLeague = await fetchChallengerLeague(platform)
      console.log('ChallengerLeague: got ' + challengerLeague.entries.length + ' entries')

      const gameList: string[] = []
      let i = 0
      for (const challenger of challengerLeague.entries) {
        console.log('Entry ' + i + '/' + challengerLeague.entries.length + ' ...')
        const puuid = challenger.puuid
        const challengerGameList = await summonerGameList(puuid, latestPatchTime, region)
        for (const game of challengerGameList) {
          if (!gameList.includes(game) && !alreadySeenGameList.includes(game)) {
            gameList.push(game)
          }
        }
        i++
      }

      console.log('Games: got ' + gameList.length + ' entries for ' + platform)
      i = 0
      for (const game of gameList) {
        console.log('Entry ' + i + '/' + gameList.length + ' ...')
        // Determine region from matchId (format: REGION_matchId)
        const matchRegion = game.split('_')[0]
        const gameMatch = await match(game, matchRegion)
        const gameTimeline = await matchTimeline(game, matchRegion)
        gameMatch.timeline = gameTimeline
        await saveMatch(client, gameMatch, latestPatch, platform)
        i++
      }
    }
  }

  console.log('Generating stats...')
  await champion_stat.makeChampionsStats(client, latestPatch, Object.keys(PLATFORMS))

  console.log('All done. Closing client.')
  await client.close()
}

async function handleRateLimit(url: URL): Promise<Response> {
  let response = await fetch(url)
  if (response.status == 429) {
    await new Promise(resolve => setTimeout(resolve, sleep_minutes * 60 * 1000))
    response = await handleRateLimit(url)
  }

  return response
}

function handleError(response: Response) {
  if (!response.ok) {
    console.log(
      'Error during fetch(' +
        response.url +
        '): STATUS ' +
        response.status +
        ' (' +
        response.statusText +
        ')'
    )
    process.exit(1)
  }
}

async function connectToDatabase() {
  // Create a MongoClient with a MongoClientOptions object to set the Stable API version
  let uri = `mongodb://${process.env.MONGO_USER}:${process.env.MONGO_PASS}@${process.env.MONGO_HOST}`
  if (
    process.env.MONGO_URI != undefined &&
    process.env.MONGO_URI != null &&
    process.env.MONGO_URI != ''
  ) {
    uri = process.env.MONGO_URI
  }
  const client = new MongoClient(uri)
  await client.connect()
  return client
}

async function fetchLatestPatchDate(client: MongoClient) {
  const database = client.db('patches')
  const patches = database.collection('patches')
  const latestPatch = await patches.find().limit(1).sort({ date: -1 }).next()
  return [latestPatch!.patch, Math.floor(latestPatch!.date.valueOf() / 1000)]
}

async function fetchChallengerLeague(platform: string) {
  const queue = 'RANKED_SOLO_5x5'
  const endpoint = `/lol/league/v4/challengerleagues/by-queue/${queue}`
  const baseUrl = getPlatformBaseUrl(platform)
  const url = `${baseUrl}${endpoint}?api_key=${api_key}`

  const challengerLeagueResponse = await handleRateLimit(new URL(url))

  handleError(challengerLeagueResponse)

  const challengerLeague = await challengerLeagueResponse.json()
  return challengerLeague
}

async function summonerGameList(puuid: string, startTime: string, region: string) {
  const baseUrl = getRegionalBaseUrl(region)
  const endpoint = `/lol/match/v5/matches/by-puuid/${puuid}/ids`
  const url = `${baseUrl}${endpoint}?queue=420&type=ranked&startTime=${startTime}&api_key=${api_key}`

  const gameListResponse = await handleRateLimit(new URL(url))
  handleError(gameListResponse)
  const gameList = await gameListResponse.json()

  return gameList
}

async function match(matchId: string, region: string) {
  const baseUrl = getRegionalBaseUrl(region)
  const endpoint = `/lol/match/v5/matches/${matchId}`
  const url = `${baseUrl}${endpoint}?api_key=${api_key}`

  const matchResponse = await handleRateLimit(new URL(url))
  handleError(matchResponse)
  const match = await matchResponse.json()

  return match
}

async function matchTimeline(matchId: string, region: string) {
  const baseUrl = getRegionalBaseUrl(region)
  const endpoint = `/lol/match/v5/matches/${matchId}/timeline`
  const url = `${baseUrl}${endpoint}?api_key=${api_key}`

  const timelineResponse = await handleRateLimit(new URL(url))
  handleError(timelineResponse)
  const timeline = await timelineResponse.json()

  return timeline
}

async function alreadySeenGames(client: MongoClient, latestPatch: string, platform: string) {
  const database = client.db('matches')
  const collectionName = `${latestPatch}_${platform}`
  const matches = database.collection(collectionName)

  const alreadySeen = await matches.distinct('metadata.matchId')
  return alreadySeen
}

async function saveMatch(client: MongoClient, match: Match, latestPatch: string, platform: string) {
  const database = client.db('matches')
  const collectionName = `${latestPatch}_${platform}`
  const matches = database.collection(collectionName)
  await matches.insertOne(match)
}

/**
 * Development mode function that generates stats from pre-loaded data
 */
async function runWithPreloadedData() {
  console.log('Using pre-loaded match data for development')

  const client = await connectToDatabase()
  try {
    const [latestPatch] = await fetchLatestPatchDate(client)
    console.log(`Latest patch: ${latestPatch}`)

    // Check if we have matches for this patch (including platform-specific collections)
    const matchesDb = client.db('matches')
    const collections = await matchesDb.listCollections().toArray()
    const collectionNames = collections.map(c => c.name)

    // Find collections for this patch (both global and platform-specific)
    const patchCollections = collectionNames.filter(
      name => name === latestPatch || name.startsWith(`${latestPatch}_`)
    )

    if (patchCollections.length === 0) {
      console.error(`❌ No match data found for patch ${latestPatch}`)
      console.log('💡 Please run the data import script first:')
      console.log('   node dev/scripts/setup-db.js')
      return
    }

    console.log(
      `Found ${patchCollections.length} match collection(s): ${patchCollections.join(', ')}`
    )

    // Extract platforms from collection names (e.g., "15.1_EUW1" -> "EUW1")
    const platforms = patchCollections
      .filter(name => name.startsWith(`${latestPatch}_`))
      .map(name => name.replace(`${latestPatch}_`, ''))

    // Generate stats for each platform
    if (platforms.length > 0) {
      await champion_stat.makeChampionsStats(client, latestPatch, platforms)
    } else {
      // Fallback for old-style collections without platform suffix
      await champion_stat.makeChampionsStats(client, latestPatch)
    }

    console.log('🎉 All stats generated successfully!')
    console.log('🚀 Your development database is ready for frontend testing!')
  } catch (error) {
    console.error('❌ Error in development mode:', error)
    throw error
  } finally {
    await client.close()
  }
}