Uxmp\Core\Component\SubSonic\GetRandomSongsDataProvider

Complexity

Total Complexity

6

Size/Duplication

Total Lines	93
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	1

3 Methods

Rating	Name	Duplication	Size	Complexity
A	retrieveSongs()	0	19	2
A	getRandomSongs()	0	28	3
A	__construct()	0	5	1

<?php

declare(strict_types=1);

namespace Uxmp\Core\Component\SubSonic;

use Generator;
use Traversable;
use Usox\HyperSonic\FeatureSet\V1161\Contract\GetRandomSongsDataProviderInterface;
use Uxmp\Core\Component\Song\RandomSongsRetrieverInterface;
use Uxmp\Core\Orm\Model\SongInterface;
use Uxmp\Core\Orm\Repository\CatalogRepositoryInterface;
use Uxmp\Core\Orm\Repository\GenreRepositoryInterface;

/**
 * Retrieves songs in random order, optionally filtered by the given config
 */
final class GetRandomSongsDataProvider implements GetRandomSongsDataProviderInterface
{
    /** @var int */
    private const DEFAULT_SONG_LIMIT = 10;

    public function __construct(
        private readonly RandomSongsRetrieverInterface $randomSongsRetriever,
        private readonly CatalogRepositoryInterface $catalogRepository,
        private readonly GenreRepositoryInterface $genreRepository,
    ) {
    }

    /**
     * @return Traversable<array{
     *  id: int|string,
     *  name: string,
     *  albumId: int|string,
     *  artistName: string,
     *  albumName: string,
     *  trackNumber: int,
     *  year: int,
     *  genre: string,
     *  coverArtId: string,
     *  length: int,
     *  filesize: int
     *  }>
     */
    public function getRandomSongs(
        ?string $musicFolderId,
        ?int $limit = self::DEFAULT_SONG_LIMIT,
        ?string $genreName = null,
        ?int $fromYear = null,
        ?int $toYear = null
    ): Traversable {
        $catalog = null;
        $genre = null;
        if ($musicFolderId !== null) {
            $catalog = $this->catalogRepository->find((int) $musicFolderId);
        }

        if ($genreName !== null) {
            $genre = $this->genreRepository->findOneBy([
                'title' => $genreName,
            ]);
        }

        $songs = $this->randomSongsRetriever->retrieve(
            $limit ?? self::DEFAULT_SONG_LIMIT,
            $catalog,
            $genre,
            $fromYear,
            $toYear
        );

        return $this->retrieveSongs($songs);
    }

    /**
     * @param iterable<SongInterface> $songs
     *
     * @return Generator<array{
     *  id: int|string,
     *  name: string,
     *  albumId: int|string,
     *  artistName: string,
     *  albumName: string,
     *  trackNumber: int,
     *  year: int,
     *  genre: string,
     *  coverArtId: string,
     *  length: int,
     *  filesize: int
     * }>
     */
    private function retrieveSongs(iterable $songs): Generator
    {
        foreach ($songs as $song) {
            $artist = $song->getArtist();
            $album = $song->getAlbum();
            $songId = $song->getId();

            yield [
                'id' => $songId,
                'albumId' => $album->getId(),
                'name' => $song->getTitle(),
                'albumName' => (string) $album->getTitle(),
                'artistName' => (string) $artist->getTitle(),
                'trackNumber' => $song->getTrackNumber(),
                'year' => (int) $album->getYear(),
                'genre' => 'Aggi', // @todo add genre
                'coverArtId' => sprintf('song-%d', $songId),
                'length' => $song->getLength(),
                'filesize' => $song->getFileSize(),
            ];
        }
    }
}