YouTubeController.php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

use YouTube;
use App\Helpers\Helper;
use Exception;
use Log;
use Cache;

use App\Repositories\YouTubeApiRepository;

class YouTubeController extends Controller
{
    /**
     * Default output format for latest video API.
     *
     * @var string
     */
    protected $defaultFormat = '{title} - {url}';

    /**
     * Valid 'variables' for the output format in latest video API.
     * Make sure to update the replacemtnts in both `latestVideo()` and `latestPlVideo()` if this array changes.
     *
     * @var array
     */
    protected $formatSearch = ['{id}', '{url}', '{title}'];

    /**
     * YouTube API repository, for handling logic around caching.
     *
     * @var YouTubeApiRepository
     */
    protected $api;

    public function __construct(YouTubeApiRepository $api)
    {
        $this->api = $api;
    }

    /**
     * Retrieves the latest public YouTube upload from the specified identifier.
     *
     * @param  Request $request
     * @return Response
     */
    public function latestVideo(Request $request)
    {
        $type = null;
        if ($request->has('user')) {
            $type = 'user';
        }

        if ($request->has('handle')) {
            $type = 'handle';
        }

        if ($request->has('id')) {
            $type = 'id';
        }

        if (empty($type)) {
            return Helper::text('You need to specify a "user" (/user/ URLs), an "id" (/channel/ URLs) or the YouTube channel handle (@).');
        }

        $id = $request->input($type, null);
        $format = $request->input('format', $this->defaultFormat);
        $exclude = $request->input('exclude', null);
        $include = $request->input('include', null);
        $noShorts = $request->input('no_shorts', '0');
        $shortsUrl = $request->has('shorts_url');

        $hasMinDuration = $request->has('min_duration');
        $hasMaxDuration = $request->has('max_duration');
        $minDuration = $request->input('min_duration', null);
        $maxDuration = $request->input('max_duration', null);

        /**
         * We intentionally add an additional second to durations, to give more leeway for the API to return the correct results.
         * As YouTube can for example consider "2:00" as "2m00s595ms" or something similar.
         */
        if ($hasMinDuration) {
            $minDuration = (int) $minDuration;
            $minDuration++;
        }

        if ($hasMaxDuration) {
            $maxDuration = (int) $maxDuration;
            $maxDuration++;
        }

        // Checking for minimum 2 here, as we're adding an additional second to the duration when specified.
        if ($hasMinDuration && $minDuration < 2) {
            return Helper::text('The "min_duration" parameter has to be a number, minimum 1.');
        }

        if ($hasMaxDuration && $maxDuration < 2) {
            return Helper::text('The "max_duration" parameter has to be a number, minimum 1.');
        }

        $excludeShorts = $noShorts !== '0' && $noShorts !== 'false';

        $noLivestream = $request->input('no_livestream', '0');
        $excludeLivestream = $noLivestream !== '0' && $noLivestream !== 'false';

        $fetchExtendedDetails = $excludeShorts || $excludeLivestream || $hasMinDuration || $hasMaxDuration;

        /**
         * URL format used for the `{url}` replacement in the format string.
         * Can be overridden by `shortsUrl` parameter before we do the actual replacements of `format`.
         */
        $urlFormat = 'https://youtu.be/%s';

        if ($exclude !== null) {
            $exclude = trim($exclude);
        }

        if ($include !== null) {
            $include = trim($include);
        }

        if (empty(trim($format))) {
            $format = $this->defaultFormat;
        }

        $skip = intval($request->input('skip', 0));
        $max = 50;

        if ($skip >= $max) {
            $skip = 0;
        }

        /**
         * Occasionally someone will try to pass the channel handle as the `user` parameter.
         * So let's help them out here :)
         */
        if (strpos($id, '@') === 0) {
            $type = 'handle';
        }

        /**
         * Channel IDs and old "user" URLs do not have spaces in them.
         *
         * Some users have specified their display names (example: "My Channel Name")
         * as their channel ID, which will just return an error from the YouTube API.
         *
         * To prevent unnecessary API requests, we're returning an error early as
         * this would be an invalid ID/user value anyways.
         */
        if (strpos($id, ' ') !== false) {
            return Helper::text(__('youtube.invalid_channel_value', [
                'type' => $type,
                'id' => $id,
            ]));
        }

        try {
            $parts = ['id', 'snippet', 'contentDetails'];
            switch ($type) {
                case 'user':
                    $channel = YouTube::getChannelByName($id, [], $parts);
                    break;

                case 'handle':
                    $channel = YouTube::getChannelByHandle($id, [], $parts);
                    break;

                default:
                    $channel = YouTube::getChannelById($id, [], $parts);
                    break;
            }

            if ($channel === false) {
                return Helper::text(sprintf('The specified identifier "%s" as type "%s" is invalid.', $id, $type));
            }

            $uploadsPlaylist = $channel
                ->contentDetails
                ->relatedPlaylists
                ->uploads;

            // TODO: Implement some caching
            $apiResults = YouTube::getPlaylistItemsByPlaylistId($uploadsPlaylist);
            $results = $apiResults['results'];

            /**
             * Sometimes YouTube's API returns bad data... I guess?
             */
            if (!is_array($results)) {
                return Helper::text('An error occurred retrieving videos for channel: ' . $request->input($type));
            }

            $videoIds = array_map(function($video) {
                return $video->contentDetails->videoId;
            }, $results);

            $videoDetails = [];
            if ($fetchExtendedDetails) {
                $videoDetails = $this->api->getVideoDetails($videoIds);
            }

            if ($excludeShorts) {
                $filteredVideos = $this->api->filterShorts($videoDetails);

                $results = array_filter($results, function($video) use ($filteredVideos) {
                    $videoId = $video->contentDetails->videoId;
                    return isset($filteredVideos[$videoId]);
                });
            }

            // Note: This flag only excludes a currently active livestream. Stream VODs are considered regular videos by the API.
            if ($excludeLivestream) {
                $filteredVideos = $this->api->filterLivestreams($videoDetails);

                $results = array_filter($results, function($video) use ($filteredVideos) {
                    $videoId = $video->contentDetails->videoId;
                    return isset($filteredVideos[$videoId]);
                });
            }

            // Filter by durations
            if ($hasMinDuration || $hasMaxDuration) {
                $minDuration = $minDuration ?? 0;
                $maxDuration = $maxDuration ?? 0;

                $filteredVideos = $this->api->filterByDuration($videoDetails, $minDuration, $maxDuration);

                $results = array_filter($results, function($video) use ($filteredVideos) {
                    $videoId = $video->contentDetails->videoId;
                    return isset($filteredVideos[$videoId]);
                });
            }

            /**
             * The YouTube API seems to return basic information about private videos as well,
             * even though we can't see any "real" information about them.
             *
             * This actually causes issues when we attempt to sort the videos,
             * as `videoPublishedAt` isn't a field that's available.
             *
             * Instead we filter the videos, so we only have the public ones left.
             */
            $results = array_filter($results,
                function($video) use ($exclude) {
                    $privacyStatus = $video->status->privacyStatus ?? 'private';
                    $isPublic = $privacyStatus === 'public';

                    if (empty($exclude)) {
                        return $isPublic;
                    }

                    $title = $video->snippet->title ?? '';
                    $isExcluded = stripos($title, $exclude) !== false;

                    return $isPublic && !$isExcluded;
                }
            );

            if (!empty($include)) {
                $results = array_filter($results,
                    function($video) use ($include) {
                        $title = $video->snippet->title ?? '';
                        return stripos($title, $include) !== false;
                    }
                );
            }

            if (empty($results)) {
                return Helper::text('This channel has no public videos matching the specified criteria.');
            }

            /**
             * Seems that YouTube sorts the API response for uploaded videos
             * by their upload timestamp, instead of their
             * "published publicly to YouTube" timestamp.
             *
             * With scheduled uploads, this can become an issue, so we're re-sorting
             * the whole array to take this into account.
             *
             * The fallback for `date('c', 0)` is used when `videoPublishedAt` isn't an available field.
             * All public videos (since we filter out any non-public videos earlier), _should_ have this field.
             * So it might be an unnecessary precaution.
             *
             * Turns out that `snippet` seems to contain a more accurate publishedAt date,
             * while `contentDetails` can _sometimes_ have... so we try to use `snippet` first.
             */
            usort($results, function($a, $b) {
                $publishOne = $a->snippet->publishedAt ?? $a->contentDetails->videoPublishedAt ?? date('c', 0);
                $publishTwo = $b->snippet->publishedAt ?? $b->contentDetails->videoPublishedAt ?? date('c', 0);

                return strtotime($publishTwo) - strtotime($publishOne);
            });

            $total = count($results);

            // Check if the request skips a valid amount of videos.
            if ($total < ($skip + 1)) {
                return Helper::text(sprintf('Channel only has %d public videos. Invalid skip count specified: %d.', $total, $skip));
            }

            $video = $results[$skip];
            // Title can sometimes includes HTML entities (such as '&amp;' instead of '&')
            $title = htmlspecialchars_decode($video->snippet->title, ENT_QUOTES);
            $videoId = $video->contentDetails->videoId;

            if ($shortsUrl) {
                $isShort = $this->api->isShort($videoId);
                if ($isShort) {
                    $urlFormat = 'https://youtube.com/shorts/%s';
                }
            }

            /**
             * See $this->formatSearch for a list of available variables.
             */
            $replacements = [
                // {id}
                $videoId,
                // {url}
                sprintf($urlFormat, $videoId),
                // {title}
                $title,
            ];

            return Helper::text(str_replace($this->formatSearch, $replacements, $format));
        } catch (Exception $ex) {
            $exceptionMessage = sprintf('%s%s%s', $ex->getMessage(), PHP_EOL, $ex->getTraceAsString());
            $logResult = sprintf('An error occurred in /youtube/latest_video (channel: "%s", skip: %d): %s', $request->input($type), $skip, $exceptionMessage);
            Log::error($logResult);
            return Helper::text('An error occurred retrieving videos for channel: ' . $request->input($type));
        }
    }

    /**
     * Retrieve the latest video in a YouTube playlist based on the playlist ID.
     *
     * @param  Request $request
     * @return Response
     */
    public function latestPlVideo(Request $request)
    {
        $id = $request->input('id', null);
        $skip = intval($request->input('skip', 0));
        $separator = $request->input('separator', '-');

        // Use default format, but make sure it's backwards compatible with the `separator` parameter.
        $defaultFormat = str_replace('-', $separator, $this->defaultFormat);
        $format = $request->input('format', $defaultFormat);

        if (empty($id) || trim($id) === '') {
            return Helper::text('A playlist ID has to be specified.');
        }
        try {
            $results = YouTube::getPlaylistItemsByPlaylistId($id)['results'];

            $count = count($results);
            if ($skip > $count - 1) {
                $error = sprintf('Skip count (%d) has to be lower than the amount of available videos in playlist (%d).', $skip, $count);
                return Helper::text($error);
            }

            $video = $results[$skip];
            // Title can sometimes includes HTML entities (such as '&amp;' instead of '&')
            $title = htmlspecialchars_decode($video->snippet->title, ENT_QUOTES);
            $videoId = $video->contentDetails->videoId;

            /**
             * See $this->formatSearch for a list of available variables.
             */
            $replacements = [
                // {id}
                $videoId,
                // {url}
                sprintf('https://youtu.be/%s', $videoId),
                // {title}
                $title,
            ];

            return Helper::text(str_replace($this->formatSearch, $replacements, $format));
        } catch (Exception $e) {
            return Helper::text('An error occurred retrieving playlist items with the playlist ID: ' . $id);
        }
    }

    /**
     * Searches the YouTube API for the specified string, if it's a video ID, it'll just return the video ID.
     * If it's a valid search string, and it finds a result, it'll return the video ID of the first result.
     * If neither, it will either return nothing (if the word "nightbot" is found in the user agent).
     * Or it will return an error message.
     *
     * @param  Request $request
     * @param  string  $videoId
     * @param  string  $search  Search string or video ID/URL
     * @return Response
     */
    public function videoId(Request $request, $videoId = null, $search = null)
    {
        $search = $search ?: $request->input('search', null);
        $showUrl = $request->exists('show_url');

        if (empty($search)) {
            // Send an empty response so that Nightbot doesn't attempt to 'search' the YouTube API with the returned string.
            if ($this->isNightbot($request)) {
                return Helper::text('');
            }

            return Helper::text('No search parameter specified.');
        }

        $normalizedSearch = strtolower(trim($search));
        $cacheKey = sprintf('youtube.video_id.%s', hash('sha256', $normalizedSearch));
        // Loaded from `config/youtube-cache.php` - Defaults to 3 hours
        $cacheTime = config('config.youtube-cache.search', 10800);

        /**
         * Check if search string has been cached
         */
        if (Cache::has($cacheKey)) {
            $videoId = Cache::get($cacheKey);

            if ($showUrl) {
                return Helper::text(sprintf('https://youtu.be/%s', $videoId));
            }

            return Helper::text($videoId);
        }

        // YouTube URL detected
        $parse = $this->parseURL($search);
        if ($parse !== false) {
            $video = YouTube::getVideoInfo($parse);
            if (!empty($video)) {
                $videoId = $video->id;
                Cache::put($cacheKey, $videoId, $cacheTime);

                if ($showUrl) {
                    return Helper::text(sprintf('https://youtu.be/%s', $videoId));
                }

                return Helper::text($videoId);
            }
        }

        // YouTube URL not detected, search for video
        if ($parse === false) {
            $parameters = [
                'q' => $search,
                'type' => 'video',
                'part' => 'id',
                'maxResults' => 5,
            ];

            try {
                $videos = YouTube::searchAdvanced($parameters);

                /**
                 * For some reason, certain keywords (only one that I saw was "headlines") would error out.
                 *
                 * This is because the YouTube Data API decides to return a specific channel ID for their
                 * auto-generated "News" channel, even though type is set to 'video'.
                 *
                 * Specifically talking about this channel: https://www.youtube.com/channel/UCYfdidRxbB8Qhf0Nx7ioOYw
                 *
                 * This is an ugly workaround that I did to prevent it from giving an error whenever
                 * someone searches for songs like "Drake - Headlines".
                 */
                if (!empty($videos)) {
                    foreach ($videos as $searchResult) {
                        if (property_exists($searchResult->id, 'videoId')) {
                            $video = $searchResult->id->videoId;
                            break;
                        }
                    }
                }
            } catch (Exception $ex) {
                Log::error(sprintf('An error occurred in /youtube/videoid (search query: "%s" ): %s', $search, (string) $ex));
                if ($this->isNightbot($request)) {
                    return Helper::text('');
                }

                return Helper::text('An error occurred when searching: ' . $search);
            }
        }

        if (empty($video)) {
            if ($this->isNightbot($request)) {
                return Helper::text('');
            }

            return Helper::text('Invalid video URL, video ID or search string.');
        }

        Cache::put($cacheKey, $video, $cacheTime);

        if ($showUrl) {
            $video = sprintf('https://youtu.be/%s', $video);
        }

        return Helper::text($video);
    }

    /**
     * Parses a URL and attempts to retrieve the video ID.
     * This does not validate if the video ID is valid or not, though it is intended to be done in `videoId()`.
     *
     * @param  string $url        The URL to parse
     * @return string|false       The video ID or false if it's unable to find it.
     */
    private function parseURL($url)
    {
        $url = urldecode($url);

        if (filter_var($url, FILTER_VALIDATE_URL) === false) {
            return false;
        }

        $parsed = null;
        try {
            $parsed = parse_url($url);
        } catch (Exception $e) {
            return false;
        }

        if (empty($parsed)) {
            return false;
        }

        $host = strtolower($parsed['host']);
        if ($host === 'youtu.be') {
            // Return video ID after `https://youtu.be/`
            return substr($parsed['path'], 1);
        }

        if ($host === 'youtube.com' || $host === 'www.youtube.com') {
            $query = [];
            $queryString = $parsed['query'] ?? '';
            parse_str($queryString, $query);

            if (empty($query['v'])) {
                return false;
            }

            if (!is_string($query['v'])) {
                return false;
            }

            return $query['v'];
        }

        return false;
    }

    /**
     * Checks if the request is done using Nightbot's "URL fetcher"
     *
     * @param  Request  $request
     * @return boolean
     */
    private function isNightbot(Request $request)
    {
        if (strpos($request->server('HTTP_USER_AGENT'), 'Nightbot') !== false) {
            return true;
        }

        return false;
    }
}