VideoGamesRecords\IgdbBundle\Command\SearchAndImportGamesCommand

Complexity

Total Complexity

45

Size/Duplication

Total Lines	229
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	configure()	0	17	1
D	execute()	0	88	14
A	importGames()	0	23	3
B	getPlatformNames()	0	25	10
C	updateGame()	0	52	16
A	__construct()	0	5	1

<?php

declare(strict_types=1);

namespace VideoGamesRecords\IgdbBundle\Command;

use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Style\SymfonyStyle;
use VideoGamesRecords\IgdbBundle\Entity\Game;
use VideoGamesRecords\IgdbBundle\Entity\Genre;
use VideoGamesRecords\IgdbBundle\Entity\Platform;
use VideoGamesRecords\IgdbBundle\Client\IgdbClient;

#[AsCommand(
    name: 'igdb:search-import:games',
    description: 'Search and import specific games from IGDB API by name and platform'
)]
class SearchAndImportGamesCommand extends Command
{
    public function __construct(
        private readonly IgdbClient $igdbClient,
        private readonly EntityManagerInterface $entityManager
    ) {
        parent::__construct();
    }

    protected function configure(): void
    {
        $this
            ->addArgument('name', InputArgument::REQUIRED, 'Game name to search for')
            ->addOption(
                'platform',
                'p',
                InputOption::VALUE_OPTIONAL | InputOption::VALUE_IS_ARRAY,
                'Platform ID(s) to filter by'
            )
            ->addOption('limit', 'l', InputOption::VALUE_OPTIONAL, 'Maximum number of results to process', 10)
            ->addOption('exact-match', 'x', InputOption::VALUE_NONE, 'Only import games with exact name match')
            ->addOption(
                'dry-run',
                'd',
                InputOption::VALUE_NONE,
                'Show what would be imported without actually importing'
            );
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $io = new SymfonyStyle($input, $output);

        $gameName = $input->getArgument('name');
        $platformIds = $input->getOption('platform');
        $limit = (int) $input->getOption('limit');
        $exactMatch = $input->getOption('exact-match');
        $dryRun = $input->getOption('dry-run');

        $io->title("Searching for games matching: '$gameName'");

        if (!empty($platformIds)) {
            $platformIds = array_map('intval', $platformIds);
            $io->info('Filtering by platform IDs: ' . implode(', ', $platformIds));
        }

        try {
            $games = $this->igdbClient->searchGamesByName($gameName, $platformIds, $limit);

            if (empty($games)) {
                $io->warning('No games found matching your criteria.');
                return Command::SUCCESS;
            }

            $io->info(sprintf('Found %d game(s) in IGDB', count($games)));

            $toImport = [];
            foreach ($games as $gameData) {
                // Skip if exact match required and names don't match exactly
                if ($exactMatch && strcasecmp($gameData['name'], $gameName) !== 0) {
                    continue;
                }

                // Check if game already exists in our database
                $existingGame = $this->entityManager->getRepository(Game::class)->find($gameData['id']);
                if ($existingGame) {
                    $io->note(sprintf(
                        'Game "%s" (ID: %d) already exists in database',
                        $gameData['name'],
                        $gameData['id']
                    ));
                    continue;
                }

                $toImport[] = $gameData;
            }

            if (empty($toImport)) {
                $io->success('All matching games are already in your database.');
                return Command::SUCCESS;
            }

            $io->section(sprintf('Games to import (%d):', count($toImport)));
            $table = $io->createTable();
            $table->setHeaders(['ID', 'Name', 'Platforms', 'First Release Date']);

            foreach ($toImport as $gameData) {
                $platforms = $this->getPlatformNames($gameData['platforms'] ?? []);
                $releaseDate = isset($gameData['first_release_date']) && is_numeric($gameData['first_release_date'])
                    ? date('Y-m-d', $gameData['first_release_date'])
                    : 'N/A';

                $table->addRow([
                    $gameData['id'],
                    $gameData['name'],
                    implode(', ', $platforms),
                    $releaseDate
                ]);
            }
            $table->render();

            if ($dryRun) {
                $io->note('Dry run mode - no games were imported.');
                return Command::SUCCESS;
            }

            if (!$io->confirm('Do you want to import these games?', false)) {
                $io->info('Import cancelled.');
                return Command::SUCCESS;
            }

            $this->importGames($toImport, $io);

            return Command::SUCCESS;
        } catch (\Exception $e) {
            $io->error('Failed to search and import games: ' . $e->getMessage());
            return Command::FAILURE;
        }
    }

    private function importGames(array $games, SymfonyStyle $io): void
    {
        $io->progressStart(count($games));
        $importedCount = 0;

        foreach ($games as $gameData) {
            $game = new Game();
            $this->updateGame($game, $gameData);
            $game->setId($gameData['id']);

            if (isset($gameData['created_at'])) {
                $game->setCreatedAt(new \DateTimeImmutable('@' . $gameData['created_at']));
            }

            $this->entityManager->persist($game);
            $importedCount++;
            $io->progressAdvance();
        }

        $this->entityManager->flush();
        $io->progressFinish();

        $io->success(sprintf('Successfully imported %d games!', $importedCount));
    }

    private function updateGame(Game $game, array $gameData): void
    {
        $game->setName($gameData['name']);
        $game->setSlug($gameData['slug'] ?? null);
        $game->setStoryline($gameData['storyline'] ?? null);
        $game->setSummary($gameData['summary'] ?? null);
        $game->setUrl($gameData['url'] ?? null);
        $game->setChecksum($gameData['checksum'] ?? null);
        $game->setFirstReleaseDate($gameData['first_release_date'] ?? null);

        // Gérer l'association avec version_parent (auto-référence)
        if (isset($gameData['version_parent']) && is_numeric($gameData['version_parent'])) {
            $versionParent = $this->entityManager->getRepository(Game::class)->find($gameData['version_parent']);
            $game->setVersionParent($versionParent);
        }

        // Gérer les associations ManyToMany avec les genres
        if (isset($gameData['genres']) && is_array($gameData['genres'])) {
            foreach ($gameData['genres'] as $genreId) {
                $genre = $this->entityManager->getRepository(Genre::class)->find($genreId);
                if ($genre) {
                    $game->addGenre($genre);
                }
            }
        }

        // Gérer les associations ManyToMany avec les plateformes
        if (isset($gameData['platforms']) && is_array($gameData['platforms'])) {
            foreach ($gameData['platforms'] as $platformData) {
                $platformId = null;
                if (is_object($platformData)) {
                    $platformArray = (array) $platformData;
                    $platformId = $platformArray['id'] ?? null;
                } elseif (is_array($platformData)) {
                    $platformId = $platformData['id'] ?? null;
                } elseif (is_numeric($platformData)) {
                    $platformId = $platformData;
                }

                if ($platformId) {
                    $platform = $this->entityManager->getRepository(Platform::class)->find($platformId);
                    if ($platform) {
                        $game->addPlatform($platform);
                    }
                }
            }
        }

        if (isset($gameData['updated_at'])) {
            $game->setUpdatedAt(new \DateTimeImmutable('@' . $gameData['updated_at']));
        } else {
            $game->setUpdatedAt(new \DateTimeImmutable());
        }
    }

    private function getPlatformNames(array $platforms): array
    {
        $names = [];
        foreach ($platforms as $platformData) {
            if (is_object($platformData)) {
                // Convert stdClass to array
                $platformArray = (array) $platformData;
                if (isset($platformArray['name'])) {
                    $names[] = $platformArray['name'];
                } elseif (isset($platformArray['id'])) {
                    $platform = $this->entityManager->getRepository(Platform::class)->find($platformArray['id']);
                    if ($platform) {
                        $names[] = $platform->getName();
                    }
                }
            } elseif (is_array($platformData) && isset($platformData['name'])) {
                $names[] = $platformData['name'];
            } elseif (is_numeric($platformData)) {
                $platform = $this->entityManager->getRepository(Platform::class)->find($platformData);
                if ($platform) {
                    $names[] = $platform->getName();
                }
            }
        }
        return $names;
    }
}