import { Injectable, Logger } from '@nestjs/common'; import { ConnectionService } from '../global/database/connection.service'; import type { Account, SeedSource, TierInfo } from '../global/database/schemas'; import { SEED_SOURCES } from '../global/database/schemas'; import { RiotApiClient, type RiotApexLeagueEntryDto, type RiotApexLeagueListDto, type RiotLeagueEntryDto, } from '../riot/riot-api.client'; import { toRegionalRoute, type RiotPlatformRoute, type RiotRegionalRoute, } from '../riot/riot.types'; import { DEFAULT_SEED_COLLECTION_QUEUE_TYPE, DEFAULT_SEED_COLLECTION_SOURCE_LIMIT, } from './analysis.constants'; export interface SeedCollectionOptions { collectedAt?: Date; platformRoute: RiotPlatformRoute; queueType?: string; sourceLimits?: Partial>; } export interface SeedCollectionSourceResult { source: SeedSource; discoveredEntries: number; selectedEntries: number; storedAccounts: number; skippedAccounts: number; duplicateAccounts: number; } export interface SeedCollectionResult { platformRoute: RiotPlatformRoute; regionalRoute: RiotRegionalRoute; queueType: string; sourceResults: SeedCollectionSourceResult[]; discoveredEntries: number; selectedEntries: number; storedAccounts: number; skippedAccounts: number; duplicateAccounts: number; } @Injectable() export class SeedCollectionService { private readonly logger = new Logger(SeedCollectionService.name); constructor( private readonly connectionService: ConnectionService, private readonly riotApiClient: RiotApiClient, ) {} public async collectSeedAccounts( options: SeedCollectionOptions, ): Promise { const collectedAt = options.collectedAt ?? new Date(); const platformRoute = options.platformRoute; const regionalRoute = toRegionalRoute(platformRoute); const queueType = options.queueType ?? DEFAULT_SEED_COLLECTION_QUEUE_TYPE; const sourceResults: SeedCollectionSourceResult[] = []; const seenPuuids = new Set(); for (const source of SEED_SOURCES) { const sourceLimit = this.normalizeSourceLimit( options.sourceLimits?.[source], ); const leagueList = await this.fetchSeedLeagueList( source, queueType, platformRoute, ); const selectedEntries = this.selectCandidateEntries( source, leagueList.entries, sourceLimit, ); const sourceResult: SeedCollectionSourceResult = { source, discoveredEntries: leagueList.entries.length, selectedEntries: selectedEntries.length, storedAccounts: 0, skippedAccounts: 0, duplicateAccounts: 0, }; for (const selectedEntry of selectedEntries) { if (seenPuuids.has(selectedEntry.puuid)) { sourceResult.duplicateAccounts += 1; continue; } seenPuuids.add(selectedEntry.puuid); try { await this.storeSeedAccount({ collectedAt, platformRoute, puuid: selectedEntry.puuid, regionalRoute, source, }); sourceResult.storedAccounts += 1; } catch (error) { sourceResult.skippedAccounts += 1; this.logger.warn( `Skipping seed puuid="${this.safeLogText(selectedEntry.puuid)}" source="${source}" after collection failure: ${this.safeLogText(this.errorMessage(error))}`, ); } } sourceResults.push(sourceResult); } return { platformRoute, regionalRoute, queueType, sourceResults, discoveredEntries: this.sumSourceResults( sourceResults, 'discoveredEntries', ), selectedEntries: this.sumSourceResults(sourceResults, 'selectedEntries'), storedAccounts: this.sumSourceResults(sourceResults, 'storedAccounts'), skippedAccounts: this.sumSourceResults(sourceResults, 'skippedAccounts'), duplicateAccounts: this.sumSourceResults( sourceResults, 'duplicateAccounts', ), }; } private async fetchSeedLeagueList( source: SeedSource, queueType: string, platformRoute: RiotPlatformRoute, ): Promise { if (source === 'challenger') { return this.riotApiClient.getChallengerLeagueByQueue( queueType, platformRoute, ); } if (source === 'grandmaster') { return this.riotApiClient.getGrandmasterLeagueByQueue( queueType, platformRoute, ); } return this.riotApiClient.getMasterLeagueByQueue(queueType, platformRoute); } private selectCandidateEntries( source: SeedSource, entries: RiotApexLeagueEntryDto[], sourceLimit: number, ): RiotApexLeagueEntryDto[] { if (sourceLimit <= 0) { return []; } const sortedEntries = this.deduplicateEntries(entries).sort((left, right) => this.compareApexEntries(left, right), ); if (source === 'master' && sortedEntries.length > sourceLimit) { return this.shuffleEntries(sortedEntries).slice(0, sourceLimit); } return sortedEntries.slice(0, sourceLimit); } private deduplicateEntries( entries: RiotApexLeagueEntryDto[], ): RiotApexLeagueEntryDto[] { const bestEntriesByPuuid = new Map(); for (const entry of entries) { const existingEntry = bestEntriesByPuuid.get(entry.puuid); if (!existingEntry || this.compareApexEntries(entry, existingEntry) < 0) { bestEntriesByPuuid.set(entry.puuid, entry); } } return [...bestEntriesByPuuid.values()]; } private compareApexEntries( left: RiotApexLeagueEntryDto, right: RiotApexLeagueEntryDto, ): number { if (right.leaguePoints !== left.leaguePoints) { return right.leaguePoints - left.leaguePoints; } if (right.wins !== left.wins) { return right.wins - left.wins; } if (left.losses !== right.losses) { return left.losses - right.losses; } return left.puuid.localeCompare(right.puuid); } private shuffleEntries( entries: RiotApexLeagueEntryDto[], ): RiotApexLeagueEntryDto[] { const shuffledEntries = [...entries]; for ( let currentIndex = shuffledEntries.length - 1; currentIndex > 0; currentIndex -= 1 ) { const swapIndex = Math.floor(Math.random() * (currentIndex + 1)); const currentEntry = shuffledEntries[currentIndex]; const swapEntry = shuffledEntries[swapIndex]; if (!currentEntry || !swapEntry) { continue; } shuffledEntries[currentIndex] = swapEntry; shuffledEntries[swapIndex] = currentEntry; } return shuffledEntries; } private async storeSeedAccount(params: { collectedAt: Date; platformRoute: RiotPlatformRoute; puuid: string; regionalRoute: RiotRegionalRoute; source: SeedSource; }): Promise { const account = await this.riotApiClient.getAccountByPuuid( params.puuid, params.regionalRoute, ); const [summoner, leagueEntries] = await Promise.all([ this.riotApiClient.getSummonerByPuuid( account.puuid, params.platformRoute, ), this.riotApiClient.getLeagueEntriesByPuuid( account.puuid, params.platformRoute, ), ]); const accountModel = await this.connectionService.getModel('account'); const existingAccount = await accountModel .findOne({ puuid: account.puuid }) .select('seedAddedAt') .lean | null>() .exec(); const seedAddedAt = existingAccount?.seedAddedAt ?? params.collectedAt; const storedAccount = await accountModel .findOneAndUpdate( { puuid: account.puuid }, { $set: { puuid: account.puuid, gameName: account.gameName, tagLine: account.tagLine, platformRoute: params.platformRoute, regionalRoute: params.regionalRoute, profileIconId: summoner.profileIconId, summonerLevel: summoner.summonerLevel, tiers: this.toTierInfo(leagueEntries, params.collectedAt), tiersFetchedAt: params.collectedAt, isSeed: true, seedSource: params.source, seedAddedAt, lastSeedCollectedAt: params.collectedAt, }, }, { new: true, setDefaultsOnInsert: true, upsert: true, }, ) .lean() .exec(); if (!storedAccount) { throw new Error('Failed to store seed Riot account.'); } return storedAccount; } private toTierInfo( entries: RiotLeagueEntryDto[], fetchedAt: Date, ): TierInfo[] { return entries.map((entry) => ({ queueType: entry.queueType, tier: entry.tier, rank: entry.rank, leaguePoints: entry.leaguePoints, wins: entry.wins, losses: entry.losses, fetchedAt, })); } private normalizeSourceLimit(limit: number | undefined): number { if (limit === undefined) { return DEFAULT_SEED_COLLECTION_SOURCE_LIMIT; } if (!Number.isFinite(limit) || limit < 0) { return DEFAULT_SEED_COLLECTION_SOURCE_LIMIT; } return Math.trunc(limit); } private sumSourceResults( sourceResults: SeedCollectionSourceResult[], key: keyof Pick< SeedCollectionSourceResult, | 'discoveredEntries' | 'selectedEntries' | 'storedAccounts' | 'skippedAccounts' | 'duplicateAccounts' >, ): number { return sourceResults.reduce( (total, sourceResult) => total + sourceResult[key], 0, ); } private errorMessage(error: unknown): string { return error instanceof Error ? error.message : String(error); } private safeLogText(value: string): string { return value.replace(/[\n\r\t]/g, ' ').slice(0, 500); } }