gamelog/app/Http/Controllers/GameController.php

<?php

namespace App\Http\Controllers;

use App\Models\Game;
use App\Models\GameComment;
use App\Models\Genre;
use App\Models\Platform;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Cache;

class GameController extends Controller
{
    public function index(Request $request)
    {
        $query = Game::published()->with(['genres', 'platforms']);

        // Filters
        if ($request->filled('genre')) {
            $query->whereHas('genres', fn($q) => $q->where('genres.id', $request->genre));
        }
        if ($request->filled('platform')) {
            $query->whereHas('platforms', fn($q) => $q->where('platforms.id', $request->platform));
        }
        if ($request->filled('year')) {
            $query->where('release_year', $request->year);
        }

        // Sort
        match ($request->get('sort', 'rating')) {
            'rating'  => $query->orderByDesc('rating_avg')->orderByDesc('rating_count'),
            'release' => $query->orderByDesc('release_date'),
            'title'   => $query->orderBy('title'),
            'popular' => $query->orderByDesc('library_count'),
            default   => $query->orderByDesc('rating_avg'),
        };

        $games    = $query->paginate(24)->withQueryString();
        $genres   = Genre::orderBy('name')->get();
        $platforms = Platform::orderBy('name')->get();

        $shouldNoindex = ($request->get('page', 1) > 1) ||
            (collect(['genre', 'platform', 'year', 'sort', 'q'])->filter(fn($k) => $request->filled($k))->count() >= 2);

        return view('games.index', compact('games', 'genres', 'platforms', 'shouldNoindex'));
    }

    public function show(Game $game)
    {
        $game->load([
            'genres', 'platforms', 'companies', 'screenshots', 'reviews.user',
            'collection', 'gameModes', 'themes', 'playerPerspectives', 'videos', 'websites',
            'similarGames' => fn($q) => $q->published()->with(['genres'])->limit(6),
        ]);

        $userGame   = null;
        $userReview = null;
        $userLists  = collect();
        if (auth()->check()) {
            $userGame   = $game->userGames()->where('user_id', auth()->id())->first();
            $userReview = $game->reviews()->where('user_id', auth()->id())->first();
            $userLists  = auth()->user()->lists()->get(['id', 'slug', 'title']);
        }

        $comments = $game->comments()->whereNull('parent_id')
            ->with(['user', 'replies.user'])
            ->latest()
            ->limit(20)
            ->get();

        // Use IGDB similar_games if available, otherwise fall back to genre-based
        if ($game->similarGames->isNotEmpty()) {
            $similarGames = $game->similarGames;
        } elseif ($game->genres->isNotEmpty()) {
            $similarGames = Game::published()
                ->whereHas('genres', fn($q) => $q->whereIn('genres.id', $game->genres->pluck('id')))
                ->where('id', '!=', $game->id)
                ->where('rating_count', '>=', 1)
                ->orderByDesc('rating_avg')
                ->limit(6)
                ->get();
        } else {
            $similarGames = collect();
        }

        $response = view('games.show', compact('game', 'userGame', 'userReview', 'userLists', 'comments', 'similarGames'));
        return auth()->check()
            ? $response
            : response($response)->header('Cache-Control', 'public, max-age=300');
    }

    public function search(Request $request)
    {
        $q = $request->get('q', '');
        $games = collect();

        if (strlen($q) >= 2) {
            $games = Game::search($q)->get()->filter(fn($g) => $g->status === 'published');
        }

        if ($request->expectsJson()) {
            return response()->json($games->take(6)->map(fn($g) => [
                'id'           => $g->id,
                'title'        => $g->title,
                'slug'         => $g->slug,
                'cover_thumb'  => $g->cover_thumb_url,
                'release_year' => $g->release_year,
                'rating_avg'   => $g->rating_avg,
                'url'          => route('games.show', $g),
            ])->values());
        }

        return view('games.search', compact('games', 'q'));
    }

    public function topRated(Request $request)
    {
        $page = $request->get('page', 1);
        $games = Cache::remember("games.top_rated.{$page}", 300, fn() =>
            Game::published()
                ->where('rating_count', '>=', 1)
                ->orderByDesc('rating_avg')
                ->orderByDesc('rating_count')
                ->paginate(24)
                ->withQueryString()
        );

        return view('games.top-rated', compact('games'));
    }

    public function newReleases(Request $request)
    {
        $page = $request->get('page', 1);
        $games = Cache::remember("games.new_releases.{$page}", 300, fn() =>
            Game::published()
                ->whereNotNull('release_date')
                ->where('release_date', '<=', now())
                ->orderByDesc('release_date')
                ->paginate(24)
                ->withQueryString()
        );

        return view('games.new-releases', compact('games'));
    }
}