SkinbaseNova/app/Http/Controllers/Legacy/PhotographyController.php

<?php

namespace App\Http\Controllers\Legacy;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Schema;
use App\Services\ArtworkService;
use App\Models\ContentType;

class PhotographyController extends Controller
{
    protected ArtworkService $artworks;

    public function __construct(ArtworkService $artworks)
    {
        $this->artworks = $artworks;
    }

    public function index(Request $request)
    {
        // Legacy group mapping: Photography => id 3
            // Determine the requested content type from the first URL segment (photography|wallpapers|skins)
            $segment = strtolower($request->segment(1) ?? 'photography');
            $contentSlug = in_array($segment, ['photography','wallpapers','skins','other']) ? $segment : 'photography';

            // Human-friendly group name (used by legacy templates)
            $group = ucfirst($contentSlug);

            // Try to load legacy category id only for photography (legacy mapping); otherwise prefer authoritative ContentType
            $id = null;
            if ($contentSlug === 'photography') {
                $id = 3; // legacy root id for photography in oldSite (kept for backward compatibility)
            }

            // Fetch legacy category info if available (only when we have an id)
            $category = null;
            try {
                if ($id !== null && Schema::hasTable('artworks_categories')) {
                    $category = DB::table('artworks_categories')
                        ->select('category_name', 'rootid', 'section_id', 'description', 'category_id')
                        ->where('category_id', $id)
                        ->first();
                }
            } catch (\Throwable $e) {
                $category = null;
            }

            // Page title and description: prefer legacy category when present, otherwise use ContentType data
            $ct = ContentType::where('slug', $contentSlug)->first();
            $page_title = $category->category_name ?? ($ct->name ?? ucfirst($contentSlug));
            $tidy = $category->description ?? ($ct->description ?? null);

            $perPage = 40;

            // Load artworks for the requested content type using standard pagination
            try {
                $artQuery = \App\Models\Artwork::public()
                    ->published()
                    ->whereHas('categories', function ($q) use ($ct) {
                        $q->where('categories.content_type_id', $ct->id);
                    })
                    ->with([
                        'user:id,name',
                        'categories' => function ($q) {
                            $q->select('categories.id', 'categories.content_type_id', 'categories.parent_id', 'categories.name', 'categories.slug', 'categories.sort_order')
                                ->with(['parent:id,parent_id,content_type_id,name,slug', 'contentType:id,slug,name']);
                        },
                    ])
                    ->orderByDesc('published_at');

                $artworks = $artQuery->paginate($perPage)->withQueryString();
            } catch (\Throwable $e) {
                // Return an empty paginator so views using ->links() / ->firstItem() work
                $artworks = new \Illuminate\Pagination\LengthAwarePaginator([], 0, $perPage, 1, [
                    'path' => url()->current(),
                ]);
            }

            // Load subcategories: prefer legacy table when id present and data exists, otherwise use ContentType root categories
            $subcategories = collect();
            try {
                if ($id !== null && Schema::hasTable('artworks_categories')) {
                    $subcategories = DB::table('artworks_categories')->select('category_id','category_name')->where('rootid', $id)->orderBy('category_name')->get();
                    if ($subcategories->count() == 0 && !empty($category->rootid)) {
                        $subcategories = DB::table('artworks_categories')->select('category_id','category_name')->where('rootid', $category->rootid)->orderBy('category_name')->get();
                    }
                }
            } catch (\Throwable $e) {
                $subcategories = collect();
            }

            if (! $subcategories || $subcategories->count() === 0) {
                if ($ct) {
                    $subcategories = $ct->rootCategories()
                        ->orderBy('sort_order')
                        ->orderBy('name')
                        ->get()
                        ->map(fn ($c) => (object) ['category_id' => $c->id, 'category_name' => $c->name, 'slug' => $c->slug]);
                } else {
                    $subcategories = collect();
                }
            }

            // Coerce collections to a paginator so the view's pagination helpers work
            if ($artworks instanceof \Illuminate\Database\Eloquent\Collection || $artworks instanceof \Illuminate\Support\Collection) {
                $page = (int) ($request->query('page', 1));
                $artworks = new \Illuminate\Pagination\LengthAwarePaginator($artworks->values()->all(), $artworks->count(), $perPage, $page, [
                    'path' => url()->current(),
                    'query' => request()->query(),
                ]);
            }

            // Prepare variables for the modern content-type view
            $contentType = ContentType::where('slug', $contentSlug)->first();
            $rootCategories = $contentType
                ? $contentType->rootCategories()->orderBy('sort_order')->orderBy('name')->get()
                : collect();

            $page_meta_description = $tidy;

            return view('legacy.content-type', compact('contentType','rootCategories','artworks','page_title','page_meta_description','subcategories','id'));
    }
}