SkinbaseNova/app/Http/Controllers/Web/ArtworkPageController.php

<?php

declare(strict_types=1);

namespace App\Http\Controllers\Web;

use App\Http\Controllers\Controller;
use App\Http\Resources\ArtworkResource;
use App\Models\Artwork;
use App\Models\ArtworkComment;
use App\Services\ThumbnailPresenter;
use App\Services\ErrorSuggestionService;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Http\Response;
use Illuminate\Support\Str;
use Illuminate\View\View;

final class ArtworkPageController extends Controller
{
    public function show(Request $request, int $id, ?string $slug = null): View|RedirectResponse|Response
    {
        // ── Step 1: check existence including soft-deleted ─────────────────
        $raw = Artwork::withTrashed()->where('id', $id)->first();

        if (! $raw) {
            // Artwork never existed → contextual 404
            $suggestions = app(ErrorSuggestionService::class);
            return response(view('errors.contextual.artwork-not-found', [
                'trendingArtworks' => $this->safeSuggestions(fn () => $suggestions->trendingArtworks()),
            ]), 404);
        }

        if ($raw->trashed()) {
            // Artwork permanently deleted → 410 Gone
            return response(view('errors.410'), 410);
        }

        if (! $raw->is_public || ! $raw->is_approved) {
            // Artwork exists but is private/unapproved → 403 Forbidden.
            // Show other public artworks by the same creator as recovery suggestions.
            $suggestions = app(ErrorSuggestionService::class);
            $creatorArtworks = collect();
            $creatorUsername = null;

            if ($raw->user_id) {
                $raw->loadMissing('user');
                $creatorUsername = $raw->user?->username;

                $creatorArtworks = $this->safeSuggestions(function () use ($raw) {
                    return Artwork::query()
                        ->with('user')
                        ->where('user_id', $raw->user_id)
                        ->where('id', '!=', $raw->id)
                        ->public()
                        ->published()
                        ->limit(6)
                        ->get()
                        ->map(function (Artwork $a) {
                            $slug = \Illuminate\Support\Str::slug((string) ($a->slug ?: $a->title)) ?: (string) $a->id;
                            $md   = \App\Services\ThumbnailPresenter::present($a, 'md');
                            return [
                                'id'     => $a->id,
                                'title'  => html_entity_decode((string) $a->title, ENT_QUOTES | ENT_HTML5, 'UTF-8'),
                                'author' => html_entity_decode((string) ($a->user?->name ?: $a->user?->username ?: 'Artist'), ENT_QUOTES | ENT_HTML5, 'UTF-8'),
                                'url'    => route('art.show', ['id' => $a->id, 'slug' => $slug]),
                                'thumb'  => $md['url'] ?? null,
                            ];
                        });
                });
            }

            return response(view('errors.contextual.artwork-not-found', [
                'message'          => 'This artwork is not publicly available.',
                'isForbidden'      => true,
                'creatorArtworks'  => $creatorArtworks,
                'creatorUsername'  => $creatorUsername,
                'trendingArtworks' => $this->safeSuggestions(fn () => $suggestions->trendingArtworks()),
            ]), 403);
        }

        // ── Step 2: full load with all relations ───────────────────────────
        $artwork = Artwork::with(['user.profile', 'categories.contentType', 'categories.parent.contentType', 'tags', 'stats'])
            ->where('id', $id)
            ->public()
            ->published()
            ->firstOrFail();

        $canonicalSlug = Str::slug((string) ($artwork->slug ?: $artwork->title));
        if ($canonicalSlug === '') {
            $canonicalSlug = (string) $artwork->id;
        }

        if ((string) $slug !== $canonicalSlug) {
            return redirect()->route('art.show', [
                'id' => $artwork->id,
                'slug' => $canonicalSlug,
            ], 301);
        }

        $thumbMd = ThumbnailPresenter::present($artwork, 'md');
        $thumbLg = ThumbnailPresenter::present($artwork, 'lg');
        $thumbXl = ThumbnailPresenter::present($artwork, 'xl');
        $thumbSq = ThumbnailPresenter::present($artwork, 'sq');

        $artworkData = (new ArtworkResource($artwork))->toArray($request);

        $canonical = route('art.show', ['id' => $artwork->id, 'slug' => $canonicalSlug]);
        $authorName = $artwork->user?->name ?: $artwork->user?->username ?: 'Artist';
        $description = Str::limit(trim(strip_tags(html_entity_decode((string) ($artwork->description ?? ''), ENT_QUOTES | ENT_HTML5, 'UTF-8'))), 160, '…');

        $meta = [
            'title' => sprintf('%s by %s | Skinbase', html_entity_decode((string) $artwork->title, ENT_QUOTES | ENT_HTML5, 'UTF-8'), html_entity_decode((string) $authorName, ENT_QUOTES | ENT_HTML5, 'UTF-8')),
            'description' => $description !== '' ? $description : html_entity_decode((string) $artwork->title, ENT_QUOTES | ENT_HTML5, 'UTF-8'),
            'canonical' => $canonical,
            'og_image' => $thumbXl['url'] ?? $thumbLg['url'] ?? null,
            'og_width' => $thumbXl['width'] ?? $thumbLg['width'] ?? null,
            'og_height' => $thumbXl['height'] ?? $thumbLg['height'] ?? null,
        ];

        $categoryIds = $artwork->categories->pluck('id')->filter()->values();
        $tagIds = $artwork->tags->pluck('id')->filter()->values();

        $related = Artwork::query()
            ->with(['user', 'categories.contentType'])
            ->whereKeyNot($artwork->id)
            ->public()
            ->published()
            ->where(function ($query) use ($artwork, $categoryIds, $tagIds): void {
                $query->where('user_id', $artwork->user_id);

                if ($categoryIds->isNotEmpty()) {
                    $query->orWhereHas('categories', function ($categoryQuery) use ($categoryIds): void {
                        $categoryQuery->whereIn('categories.id', $categoryIds->all());
                    });
                }

                if ($tagIds->isNotEmpty()) {
                    $query->orWhereHas('tags', function ($tagQuery) use ($tagIds): void {
                        $tagQuery->whereIn('tags.id', $tagIds->all());
                    });
                }
            })
            ->latest('published_at')
            ->limit(12)
            ->get()
            ->map(function (Artwork $item): array {
                $itemSlug = Str::slug((string) ($item->slug ?: $item->title));
                if ($itemSlug === '') {
                    $itemSlug = (string) $item->id;
                }

                $md = ThumbnailPresenter::present($item, 'md');
                $lg = ThumbnailPresenter::present($item, 'lg');

                return [
                    'id' => (int) $item->id,
                    'title' => html_entity_decode((string) $item->title, ENT_QUOTES | ENT_HTML5, 'UTF-8'),
                    'author' => html_entity_decode((string) ($item->user?->name ?: $item->user?->username ?: 'Artist'), ENT_QUOTES | ENT_HTML5, 'UTF-8'),
                    'url' => route('art.show', ['id' => $item->id, 'slug' => $itemSlug]),
                    'thumb' => $md['url'] ?? null,
                    'thumb_srcset' => ($md['url'] ?? '') . ' 640w, ' . ($lg['url'] ?? '') . ' 1280w',
                ];
            })
            ->values()
            ->all();

        // Recursive helper to format a comment and its nested replies
        $formatComment = null;
        $formatComment = function(ArtworkComment $c) use (&$formatComment) {
            $replies = $c->relationLoaded('approvedReplies') ? $c->approvedReplies : collect();

            return [
                'id'               => $c->id,
                'parent_id'        => $c->parent_id,
                'content'          => html_entity_decode((string) $c->content, ENT_QUOTES | ENT_HTML5, 'UTF-8'),
                'raw_content'      => $c->raw_content ?? $c->content,
                'rendered_content' => $c->rendered_content,
                'created_at'       => $c->created_at?->toIsoString(),
                'user'             => [
                    'id'          => $c->user?->id,
                    'name'        => $c->user?->name,
                    'username'    => $c->user?->username,
                    'display'     => $c->user?->username ?? $c->user?->name ?? 'User',
                    'profile_url' => $c->user?->username ? '/@' . $c->user->username : null,
                    'avatar_url'  => $c->user?->profile?->avatar_url,
                ],
                'replies' => $replies->map($formatComment)->values()->all(),
            ];
        };

        $comments = ArtworkComment::with(['user.profile', 'approvedReplies'])
            ->where('artwork_id', $artwork->id)
            ->where('is_approved', true)
            ->whereNull('parent_id')
            ->orderBy('created_at')
            ->limit(500)
            ->get()
            ->map($formatComment)
            ->values()
            ->all();

        return view('artworks.show', [
            'artwork' => $artwork,
            'artworkData' => $artworkData,
            'presentMd' => $thumbMd,
            'presentLg' => $thumbLg,
            'presentXl' => $thumbXl,
            'presentSq' => $thumbSq,
            'meta' => $meta,
            'relatedItems' => $related,
            'comments' => $comments,
        ]);
    }

    /** Silently catch suggestion query failures so error page never crashes. */
    private function safeSuggestions(callable $fn): mixed
    {
        try {
            return $fn();
        } catch (\Throwable) {
            return collect();
        }
    }
}