336 
    $videos = [];
337 
    $page = 1;
338 
    $perPage = 20; // Number of items per page
339 
    $seenVideos = []; // Array to track seen video ids
340 

341 
    // Function to check if the video has a poster or backdrop and is not adult
342 
    $isValidVideo = function($video) {
343 
        return (isset($video['poster_path']) || isset($video['backdrop_path'])) && (!isset($video['adult']) || $video['adult'] === false);
344 
    };
345 

346 
    // Loop until we have at least 20 videos or no more results are returned
347 
    while (count($videos) < $perPage) {
348 
        $relatedVideos = $this->request($this->getType() . '/' . $id . '/recommendations', ['page' => $page])['results'] ?? [];
349 

350 
        if (empty($relatedVideos)) {
351 
            break; // No more results
352 
        }
353 

354 
        foreach ($relatedVideos as $video) {
355 
            if (count($videos) >= $perPage) {
356 
                break;
357 
            }
358 
            if ($isValidVideo($video) && !in_array($video['id'], $seenVideos)) {
359 
                $videos[] = $video;
360 
                $seenVideos[] = $video['id'];
361 
            }

                                

                                    
51 
    {
52 
        $tmdb   = TmdbClient::create('movie');
53 
        $cache  = cache('tmdb.movie');
54 

55 
        $viewModel = new TmdbCollection(
56 
            new GenreCollection(
57 
                $cache->load('genres', fn () => $tmdb->getGenre())
58 
            ),
59 
        );
60 

61 
        if ($slug !== null) {
62 
            $id = substr($slug, strrpos($slug, '-') + 1);
63 
            $viewModel->addToCollection('similar', TmdbClient::create('movie')->getRelatedVideos($id));
64 

65 
            return view('video', [
66 
                'video' => $this->findOrFail($id, 'movie'),
67 
                'similar' => $viewModel->cut('similar')
68 
            ]);
69 
        }
70 

71 

72 
        $viewModel
73 
            ->addToCollection('popular', $cache->load('popular', fn () => $tmdb->getPopular(), '12 hours'))
74 
            ->addToCollection('now-playing', $cache->load('playing', fn () => $tmdb->getPlaying(), '12 hours'))
75 
            ->addToCollection('toprated', $cache->load('toprated', fn () => $tmdb->getTopRated(), '12 hours'));
76 


                                

                                    
68 
            (is_string($callback) && function_exists($callback))
69 
            || (is_object($callback) && ($callback instanceof Closure))
70 
        )
71 
            || (is_array($callback) && method_exists($callback[0], $callback[1]));
72 
    }
73 

74 
    public static function load($callback, ...$params)
75 
    {
76 
        if (!self::exists($callback)) {
77 
            throw new UndefinedMethod((is_array($callback) ? (!is_string($callback[0]) ? get_class($callback[0]) : (string) $callback[0]) . '->' . $callback[1] : $callback) . '() does not exists');
78 
        }
79 

80 
        return call_user_func($callback, ...array_values($params));
81 
    }
82 

83 
    public static function create(string $class, ...$args)
84 
    {
85 
        if (!class_exists($class)) {
86 
            throw new UndefinedClass('Class: ' . $class . ' does not exists');
87 
        }
88 

89 
        return new $class(...array_values($args));
90 
    }
91 

92 
    public static function name($callback): string
93 
    {

                                

                                    
106 

107 
            // set new callback method
108 
            $route->setCallback([$route->getCallback()[0], $call_method]);
109 
        }
110 

111 
        // escape grouped/nested named parameter
112 
        $route->setParameters($this->escapeNestedParameters($route->getParameters()));
113 

114 
        // trigger route middleware event
115 
        $this->triggerEvent(IRoute::EVENTS['callback'], $route);
116 

117 
        // load router callback
118 
        return CallbackHandler::load(
119 
            $route->getCallback(),
120 
            ...CallbackHandler::reflect(
121 
                $route->getParameters(),
122 
                $route->getCallback(),
123 
                array_merge($this->getReflectionParameters(), [$route])
124 
            )
125 
        );
126 
    }
127 

128 
    public function callMiddlewares($middlewares): void
129 
    {
130 
        foreach ((array) $middlewares as $middleware) {
131 
            $class = CallbackHandler::create($middleware);

                                

                                    
90 
                // utilize method required paramiters
91 
                $route->setParameters(
92 
                    $this->applyFilters(self::FILTER['parameters'], $this->utilizeRouteParam($matches, $route))
93 
                );
94 

95 
                // set Url to route
96 
                $route->setUrl($url);
97 

98 
                // create route dispatcher
99 
                $dispatcher = new RouteDispatcher($this);
100 

101 
                // dispatch route callback
102 
                return $dispatcher->dispatch($route);
103 
            }
104 
        }
105 

106 
        // call fallback
107 
        if (isset($this->fallback) && CallbackHandler::exists($this->fallback)) {
108 
            CallbackHandler::load($this->fallback);
109 
        }
110 

111 
        // not found any route for this path
112 
        throw new NotFoundException('the route does not matched..');
113 
    }
114 

115 
    /**

                                

                                    
91 
    }
92 

93 
    /**
94 
     * Run The Application
95 
     * @return void
96 
     */
97 
    public static function run(): void
98 
    {
99 
        // load application initial kernels
100 
        self::$app->loadKernels('boot');
101 

102 
        // render router result
103 
        echo self::$app->router->resolve();
104 

105 
        // load application initial kernels
106 
        self::$app->loadKernels('shutdown');
107 
    }
108 

109 
    /**
110 
     * Check Anu Component added to the Application
111 
     * @param string $key 
112 
     * @return bool 
113 
     */
114 
    public static function hasComponent(string $key): bool
115 
    {
116 
        return isset(self::$app->components[$key]);

                                

                                    
14 
    'tmp_dir'   => config('app.tmp_dir'),
15 
    'except'    => ['/admin/*', '/embed/*', '/search/*'],
16 
]);
17 

18 
// serve from cache if production mode
19 
if (!is_dev()) {
20 
    $siteCache->serve();
21 
}
22 

23 
// create a new application instance for this http request
24 
Application::create(__DIR__)
25 
    ->registerKernel(App\Http\Kernels\AppKernel::class)
26 
    ->run();
27 

28 
// stop the application execution process
29 
exit;
30