Core Classes

public function getRankedTeams(int $week, array $teams, array $games): array
{
    foreach ($teams as $team) {
        $this->doleOutInitialMarbles($team, $games);
    }

    foreach ($this->gamesUntilWeek($week, $games) as $game) {
        $this->awardMarbles($game);
    }

    $teams = $this->removeTeamsWithoutMarbles($teams);

    return $this->applyStandardCompetitionRanking($teams);
}

public function determineMostRecentWeekWithAllGamesCompleted(array $games): int
{
    $gamesByWeek = [];

    foreach ($games as $game) {
        $gamesByWeek[$game->weekNumber][] = $game;
    }

    ksort($gamesByWeek);

    $mostRecentCompleteWeek = 0;

    foreach ($gamesByWeek as $week => $gamesForTheWeek) {
        if ($this->isWeekComplete($gamesForTheWeek)) {
            $mostRecentCompleteWeek = $week;
        }
    }

    return $mostRecentCompleteWeek;
}

private function doleOutInitialMarbles(Team $team, array $games): void
{
    if ($team->subdivision !== Subdivision::FBS) {
        return;
    }

    $initialMarbles = 100;

    $powerConferences = [
        Conference::BigTen,
        Conference::Big12,
        Conference::ACC,
        Conference::SEC,
    ];

    // Filter out conference championships
    $games = array_filter($games, static function (Game $game): bool {
        return $game->weekNumber !== 15;
    });

    foreach ($this->getOpponents($team, $games) as $opponent) {
        // Add 10 marbles if opponent is a power conference team
        if (in_array($opponent->conference, $powerConferences, true)) {
            $initialMarbles += 10;
        }

        // Add 10 marbles if the opponent is Notre Dame
        if ($opponent->teamName === 'Notre Dame') {
            $initialMarbles += 10;
        }
    }

    $team->receiveMarbles($initialMarbles);
}

private function awardMarbles(Game $game): void
{
    // ... logging context setup ...

    $winner = $this->getWinner($game);
    $loser = $this->getLoser($game);

    if ($loser->subdivision === Subdivision::FCS) {
        $this->logger->debug('Loser was FCS. No marbles to move.', $loggerContext);
        return;
    }

    $winPercentage = $this->determineWinPercentage($game);

    $marblesToMove = (int) round($loser->getMarbles() * $winPercentage);

    $loser->giveUpMarbles($marblesToMove);
    $winner->receiveMarbles($marblesToMove);

    $this->logger->debug('Marbles awarded.', $loggerContext);
}

private function determineWinPercentage(Game $game): float
{
    if ($this->getWinner($game)->subdivision === Subdivision::FCS) {
        return 0.25;
    }

    if ($game->neutralSite) {
        return 0.2;
    }

    if ($game->winner === Winner::Away) {
        return 0.25;
    }

    return 0.2;
}

private function applyStandardCompetitionRanking(array $teams): array
{
    $teams = $this->sortByMarblesDescendingThenAlphabetically($teams);

    $rankedTeams = [];
    $currentRank = 1;
    $previousMarbles = null;
    $teamsAtCurrentMarbleCount = 0;

    foreach ($teams as $team) {
        if ($previousMarbles !== null && $team->getMarbles() < $previousMarbles) {
            $currentRank += $teamsAtCurrentMarbleCount;
            $teamsAtCurrentMarbleCount = 0;
        }

        $teamsAtCurrentMarbleCount++;
        $previousMarbles = $team->getMarbles();
        $team->setMarbleRank($currentRank);

        $rankedTeams[] = $team;
    }

    return $rankedTeams;
}

public function __construct(
    public readonly TeamId $id,
    public readonly string $teamName,
    public readonly Subdivision $subdivision,
    public readonly Conference $conference,
) {}

public function receiveMarbles(int $marbles): void
{
    if ($marbles < 0) {
        throw new InvalidArgumentException('Marbles cannot be negative');
    }

    $this->marbles += $marbles;
}

public function giveUpMarbles(int $marbles): void
{
    if ($marbles < 0) {
        throw new InvalidArgumentException('Marbles cannot be negative');
    }

    $this->marbles -= $marbles;
}

public function getMarbles(): int
{
    return $this->marbles;
}

public function setMarbleRank(int $rank): void
{
    if ($rank < 0) {
        throw new InvalidArgumentException('Rank cannot be negative');
    }

    $this->marbleRank = $rank;
}

public function getMarbleRank(): int
{
    return $this->marbleRank;
}

public function __construct(
    public readonly GameId $id,
    public readonly DateTimeInterface $date,
    public readonly int $weekNumber,
    public readonly bool $neutralSite,
    public readonly Team $homeTeam,
    public readonly Team $awayTeam,
    public readonly Winner|null $winner,
) {}

interface TeamRepository
{
    /** @return Team[] */
    public function getTeams(): array;

    public function getTeam(TeamId $teamId): Team;
}

public function getTeams(): array
{
    $query = $this->pdo->query(
        'SELECT id, name, subdivision, conference FROM teams',
        PDO::FETCH_ASSOC,
    );

    if ($query === false) {
        throw new RuntimeException('Failed to fetch teams from database');
    }

    $teams = [];

    foreach ($query as $row) {
        $teams[] = new Team(
            TeamId::fromDatabase($row['id']),
            $row['name'],
            Subdivision::fromString($row['subdivision']),
            Conference::fromString($row['conference']),
        );
    }

    return $teams;
}

public function getTeams(): array
{
    if ($this->identityMap->count() === 0) {
        $teams = $this->repository->getTeams();

        foreach ($teams as $team) {
            $this->identityMap->add($team->id, $team);
        }
    }

    return $this->identityMap->getAll();
}

interface GameRepository
{
    /** @return Game[] */
    public function getGames(): array;
}

public function getGames(): array
{
    $query = $this->pdo->query(
        'SELECT id, date, week_number, neutral_site, home_team_id, away_team_id, winner FROM games',
        PDO::FETCH_ASSOC,
    );

    if ($query === false) {
        throw new RuntimeException('Failed to fetch games from database');
    }

    $games = [];

    // Load all teams to build up the cache in the team repository
    $this->teamRepository->getTeams();

    foreach ($query as $row) {
        $gameDate = DateTimeImmutable::createFromFormat(DateFormat::SQLITE, $row['date']);

        if ($gameDate === false) {
            throw new RuntimeException('Failed to parse game date: ' . $row['date']);
        }

        $winner = null;

        if ($row['winner'] !== null) {
            $winner = Winner::from($row['winner']);
        }

        $games[] = new Game(
            GameId::fromDatabase($row['id']),
            $gameDate,
            (int) $row['week_number'],
            (bool) $row['neutral_site'],
            $this->teamRepository->getTeam(TeamId::fromDatabase($row['home_team_id'])),
            $this->teamRepository->getTeam(TeamId::fromDatabase($row['away_team_id'])),
            $winner,
        );
    }

    return $games;
}