<?php

declare(strict_types=1);

namespace App\Http\Controllers\Studio;

use App\Http\Controllers\Controller;
use App\Models\Artwork;
use App\Models\Category;
use App\Models\ContentType;
use App\Models\ArtworkVersion;
use App\Services\ArtworkEvolutionService;
use App\Services\Cdn\ArtworkCdnPurgeService;
use App\Services\ArtworkSearchIndexer;
use App\Services\ArtworkAttributionService;
use App\Services\TagService;
use App\Services\ArtworkVersioningService;
use App\Services\Studio\StudioArtworkQueryService;
use App\Services\Studio\StudioBulkActionService;
use App\Services\Tags\TagDiscoveryService;
use Carbon\Carbon;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\File;
use Illuminate\Support\Facades\Validator;
use Illuminate\Validation\ValidationException;
use Symfony\Component\HttpKernel\Exception\TooManyRequestsHttpException;

/**
 * JSON API endpoints for the Studio artwork manager.
 */
final class StudioArtworksApiController extends Controller
{
    public function __construct(
        private readonly StudioArtworkQueryService $queryService,
        private readonly StudioBulkActionService $bulkService,
        private readonly ArtworkVersioningService $versioningService,
        private readonly ArtworkSearchIndexer $searchIndexer,
        private readonly TagDiscoveryService $tagDiscoveryService,
        private readonly TagService $tagService,
        private readonly ArtworkCdnPurgeService $cdnPurge,
    ) {}

    /**
     * GET /api/studio/artworks
     * List artworks with search, filter, sort, pagination.
     */
    public function index(Request $request): JsonResponse
    {
        $userId = $request->user()->id;

        $filters = $request->only([
            'q', 'status', 'category', 'tags', 'date_from', 'date_to',
            'performance', 'sort',
        ]);

        $perPage = (int) $request->get('per_page', 24);
        $perPage = min(max($perPage, 12), 100);

        $paginator = $this->queryService->list($userId, $filters, $perPage);

        // Transform the paginator items to a clean DTO
        $items = collect($paginator->items())->map(fn ($artwork) => $this->transformArtwork($artwork));

        return response()->json([
            'data' => $items,
            'meta' => [
                'current_page' => $paginator->currentPage(),
                'last_page'    => $paginator->lastPage(),
                'per_page'     => $paginator->perPage(),
                'total'        => $paginator->total(),
            ],
        ]);
    }

    /**
     * POST /api/studio/artworks/bulk
     * Execute bulk operations.
     */
    public function bulk(Request $request): JsonResponse
    {
        $validator = Validator::make($request->all(), [
            'action'      => 'required|string|in:publish,unpublish,archive,unarchive,delete,change_category,add_tags,remove_tags',
            'artwork_ids' => 'required|array|min:1|max:200',
            'artwork_ids.*' => 'integer',
            'params'      => 'sometimes|array',
            'params.category_id' => 'sometimes|integer|exists:categories,id',
            'params.tag_ids'     => 'sometimes|array',
            'params.tag_ids.*'   => 'integer|exists:tags,id',
            'confirm'     => 'required_if:action,delete|string',
        ]);

        if ($validator->fails()) {
            return response()->json(['errors' => $validator->errors()], 422);
        }

        $data = $validator->validated();

        // Require explicit DELETE confirmation
        if ($data['action'] === 'delete' && ($data['confirm'] ?? '') !== 'DELETE') {
            return response()->json([
                'errors' => ['confirm' => ['You must type DELETE to confirm permanent deletion.']],
            ], 422);
        }

        $result = $this->bulkService->execute(
            $request->user()->id,
            $data['action'],
            $data['artwork_ids'],
            $data['params'] ?? [],
        );

        $statusCode = $result['failed'] > 0 && $result['success'] === 0 ? 422 : 200;

        return response()->json($result, $statusCode);
    }

    /**
     * PUT /api/studio/artworks/{id}
     * Update artwork details (title, description, visibility).
     */
    public function update(Request $request, int $id, ArtworkAttributionService $attribution): JsonResponse
    {
        $artwork = $request->user()->artworks()->findOrFail($id);
        $evolution = app(ArtworkEvolutionService::class);

        $validated = $request->validate([
            'title'       => 'sometimes|string|max:255',
            'description' => 'sometimes|nullable|string|max:5000',
            'is_public'   => 'sometimes|boolean',
            'visibility'  => 'sometimes|string|in:public,unlisted,private',
            'mode'        => 'sometimes|string|in:now,schedule',
            'publish_at'  => 'sometimes|nullable|string|date',
            'timezone'    => 'sometimes|nullable|string|max:64',
            'category_id' => 'sometimes|nullable|integer|exists:categories,id',
            'content_type_id' => 'sometimes|nullable|integer|exists:content_types,id',
            'tags'        => 'sometimes|array|max:15',
            'tags.*'      => 'string|max:64',
            'title_source' => 'sometimes|nullable|string|in:manual,ai_generated,ai_applied,mixed',
            'description_source' => 'sometimes|nullable|string|in:manual,ai_generated,ai_applied,mixed',
            'tags_source' => 'sometimes|nullable|string|in:manual,ai_generated,ai_applied,mixed',
            'category_source' => 'sometimes|nullable|string|in:manual,ai_generated,ai_applied,mixed',
            'group' => 'sometimes|nullable|string|max:90',
            'primary_author_user_id' => 'sometimes|nullable|integer|min:1',
            'contributor_user_ids' => 'sometimes|array|max:20',
            'contributor_user_ids.*' => 'integer|min:1',
            'contributor_credits' => 'sometimes|array|max:20',
            'contributor_credits.*.user_id' => 'required|integer|min:1',
            'contributor_credits.*.credit_role' => 'nullable|string|max:80',
            'contributor_credits.*.is_primary' => 'nullable|boolean',
            'evolution_target_artwork_id' => 'sometimes|nullable|integer|min:1',
            'evolution_relation_type' => 'sometimes|nullable|string|in:remake_of,remaster_of,revision_of,inspired_by,variation_of',
            'evolution_note' => 'sometimes|nullable|string|max:1200',
        ]);

        $hasAttributionUpdates = array_key_exists('group', $validated)
            || array_key_exists('primary_author_user_id', $validated)
            || array_key_exists('contributor_user_ids', $validated)
            || array_key_exists('contributor_credits', $validated);
        $hasEvolutionUpdates = array_key_exists('evolution_target_artwork_id', $validated)
            || array_key_exists('evolution_relation_type', $validated)
            || array_key_exists('evolution_note', $validated);

        $attributionPayload = [
            'group' => $validated['group'] ?? $artwork->group?->slug,
            'primary_author_user_id' => $validated['primary_author_user_id'] ?? $artwork->primary_author_user_id,
            'contributor_user_ids' => $validated['contributor_user_ids'] ?? $artwork->contributors()->pluck('user_id')->all(),
            'contributor_credits' => $validated['contributor_credits'] ?? $artwork->contributors()->get()->map(fn ($contributor): array => [
                'user_id' => (int) $contributor->user_id,
                'credit_role' => $contributor->credit_role,
                'is_primary' => (bool) $contributor->is_primary,
            ])->values()->all(),
        ];

        $visibility = (string) ($validated['visibility'] ?? ($artwork->visibility ?: ((bool) $artwork->is_public ? Artwork::VISIBILITY_PUBLIC : Artwork::VISIBILITY_PRIVATE)));
        $mode = (string) ($validated['mode'] ?? ($artwork->artwork_status === 'scheduled' ? 'schedule' : 'now'));
        $timezone = array_key_exists('timezone', $validated)
            ? $validated['timezone']
            : $artwork->artwork_timezone;

        $publishAt = null;
        if ($mode === 'schedule' && ! empty($validated['publish_at'])) {
            try {
                $publishAt = Carbon::parse($validated['publish_at'])->utc();
            } catch (\Throwable) {
                return response()->json(['errors' => ['publish_at' => ['Invalid publish date/time.']]], 422);
            }

            if ($publishAt->lte(now()->addMinute())) {
                return response()->json(['errors' => ['publish_at' => ['Scheduled publish time must be at least 1 minute in the future.']]], 422);
            }
        } elseif ($mode === 'schedule') {
            return response()->json(['errors' => ['publish_at' => ['Choose a date and time for scheduled publishing.']]], 422);
        }

        // Extract tags and category before updating core fields
        $tags = $validated['tags'] ?? null;
        $categoryId = $validated['category_id'] ?? null;
        $contentTypeId = $validated['content_type_id'] ?? null;
        $evolutionPayload = [
            'target_artwork_id' => $validated['evolution_target_artwork_id'] ?? null,
            'relation_type' => $validated['evolution_relation_type'] ?? null,
            'note' => $validated['evolution_note'] ?? null,
        ];
        unset($validated['tags'], $validated['category_id'], $validated['content_type_id'], $validated['visibility'], $validated['mode'], $validated['publish_at'], $validated['timezone'], $validated['group'], $validated['primary_author_user_id'], $validated['contributor_user_ids'], $validated['contributor_credits'], $validated['evolution_target_artwork_id'], $validated['evolution_relation_type'], $validated['evolution_note']);

        $validated['visibility'] = $visibility;
        $validated['artwork_timezone'] = $timezone;

        if ($mode === 'schedule' && $publishAt) {
            $validated['is_public'] = false;
            $validated['is_approved'] = true;
            $validated['publish_at'] = $publishAt;
            $validated['published_at'] = null;
            $validated['artwork_status'] = 'scheduled';
        } else {
            $validated['is_public'] = $visibility !== Artwork::VISIBILITY_PRIVATE;
            $validated['is_approved'] = true;
            $validated['publish_at'] = null;
            $validated['artwork_status'] = 'published';

            if (($validated['is_public'] ?? false) && ! $artwork->published_at) {
                $validated['published_at'] = now();
            }

            if ($visibility === Artwork::VISIBILITY_PRIVATE) {
                $validated['published_at'] = $artwork->published_at;
            }
        }

        if ($categoryId === null && $contentTypeId !== null) {
            $categoryId = $this->resolveCategoryIdForContentType((int) $contentTypeId);
        }

        $artwork->update($validated);

        // Sync category
        if ($categoryId !== null) {
            $artwork->categories()->sync([(int) $categoryId]);
        }

        // Sync tags through the shared tag service so pivot source/usage rules stay valid.
        if ($tags !== null) {
            try {
                $this->tagService->syncStudioTags(
                    $artwork,
                    $tags,
                    (string) ($validated['tags_source'] ?? 'manual')
                );
            } catch (ValidationException $exception) {
                return response()->json(['errors' => $exception->errors()], 422);
            }
        }

        if ($hasAttributionUpdates) {
            $artwork = $attribution->apply($artwork->fresh(['group.members', 'contributors', 'primaryAuthor.profile']), $request->user(), $attributionPayload);
        }

        if ($hasEvolutionUpdates) {
            try {
                $evolution->syncPrimaryRelation($artwork->fresh(['group.members']), $request->user(), $evolutionPayload);
            } catch (ValidationException $exception) {
                return response()->json(['errors' => $exception->errors()], 422);
            }
        }

        // Reindex in Meilisearch — dispatches IndexArtworkJob which writes directly, no Scout hop.
        $this->searchIndexer->update($artwork);

        // Reload relationships for response
        $artwork->load(['categories.contentType', 'tags', 'group', 'primaryAuthor.profile', 'contributors.user.profile']);
        $primaryCategory = $artwork->categories->first();

        return response()->json([
            'success' => true,
            'artwork' => [
                'id'              => $artwork->id,
                'title'           => $artwork->title,
                'description'     => $artwork->description,
                'is_public'       => (bool) $artwork->is_public,
                'visibility'      => $artwork->visibility ?: ((bool) $artwork->is_public ? Artwork::VISIBILITY_PUBLIC : Artwork::VISIBILITY_PRIVATE),
                'publish_mode'    => $artwork->artwork_status === 'scheduled' ? 'schedule' : 'now',
                'publish_at'      => $artwork->publish_at?->toIso8601String(),
                'artwork_status'  => $artwork->artwork_status,
                'artwork_timezone' => $artwork->artwork_timezone,
                'slug'            => $artwork->slug,
                'group_slug'      => $artwork->group?->slug,
                'primary_author_user_id' => (int) ($artwork->primary_author_user_id ?: $artwork->user_id),
                'contributor_user_ids' => $artwork->contributors->pluck('user_id')->map(fn ($contributorId): int => (int) $contributorId)->values()->all(),
                'contributor_credits' => $artwork->contributors->map(fn ($contributor): array => [
                    'user_id' => (int) $contributor->user_id,
                    'credit_role' => $contributor->credit_role,
                    'is_primary' => (bool) $contributor->is_primary,
                ])->values()->all(),
                'content_type_id' => $primaryCategory?->contentType?->id,
                'category_id'     => $primaryCategory?->id,
                'tags'            => $artwork->tags->map(fn ($t) => ['id' => $t->id, 'name' => $t->name, 'slug' => $t->slug])->values()->all(),
                'title_source'    => $artwork->title_source ?: 'manual',
                'description_source' => $artwork->description_source ?: 'manual',
                'tags_source'     => $artwork->tags_source ?: 'manual',
                'category_source' => $artwork->category_source ?: 'manual',
                'evolution_relation' => $evolution->editorRelation($artwork, $request->user()),
            ],
        ]);
    }

    public function evolutionOptions(Request $request, int $id): JsonResponse
    {
        $artwork = $request->user()->artworks()->findOrFail($id);

        $validated = $request->validate([
            'search' => ['nullable', 'string', 'max:120'],
        ]);

        $evolution = app(ArtworkEvolutionService::class);

        return response()->json([
            'data' => $evolution->manageableSearchOptions($artwork, $request->user(), (string) ($validated['search'] ?? '')),
            'meta' => [
                'selected' => $evolution->editorRelation($artwork, $request->user()),
            ],
        ]);
    }

    private function resolveCategoryIdForContentType(int $contentTypeId): ?int
    {
        $contentType = ContentType::query()->find($contentTypeId);
        if (! $contentType) {
            return null;
        }

        $category = $contentType->rootCategories()
            ->where('is_active', true)
            ->orderBy('sort_order')
            ->orderBy('name')
            ->first();

        if (! $category) {
            $category = Category::query()
                ->where('content_type_id', $contentType->id)
                ->where('is_active', true)
                ->orderByRaw('CASE WHEN parent_id IS NULL THEN 0 ELSE 1 END')
                ->orderBy('sort_order')
                ->orderBy('name')
                ->first();
        }

        return $category?->id;
    }

    /**
     * POST /api/studio/artworks/{id}/toggle
     * Toggle publish/unpublish/archive for a single artwork.
     */
    public function toggle(Request $request, int $id): JsonResponse
    {
        $validator = Validator::make($request->all(), [
            'action' => 'required|string|in:publish,unpublish,archive,unarchive',
        ]);

        if ($validator->fails()) {
            return response()->json(['errors' => $validator->errors()], 422);
        }

        $result = $this->bulkService->execute(
            $request->user()->id,
            $validator->validated()['action'],
            [$id],
        );

        if ($result['success'] === 0) {
            return response()->json(['error' => 'Action failed', 'details' => $result['errors']], 404);
        }

        return response()->json(['success' => true]);
    }

    /**
     * GET /api/studio/artworks/{id}/analytics
     * Analytics data for a single artwork.
     */
    public function analytics(Request $request, int $id): JsonResponse
    {
        $artwork = $request->user()->artworks()
            ->with(['stats', 'awardStat'])
            ->findOrFail($id);

        $stats = $artwork->stats;

        return response()->json([
            'artwork' => [
                'id'    => $artwork->id,
                'title' => $artwork->title,
                'slug'  => $artwork->slug,
            ],
            'analytics' => [
                'views'               => (int) ($stats?->views ?? 0),
                'favourites'          => (int) ($stats?->favorites ?? 0),
                'shares'              => (int) ($stats?->shares_count ?? 0),
                'comments'            => (int) ($stats?->comments_count ?? 0),
                'downloads'           => (int) ($stats?->downloads ?? 0),
                'ranking_score'       => (float) ($stats?->ranking_score ?? 0),
                'heat_score'          => (float) ($stats?->heat_score ?? 0),
                'engagement_velocity' => (float) ($stats?->engagement_velocity ?? 0),
            ],
        ]);
    }

    private function transformArtwork($artwork): array
    {
        $stats = $artwork->stats ?? null;

        return [
            'id'              => $artwork->id,
            'title'           => $artwork->title,
            'slug'            => $artwork->slug,
            'thumb_url'       => $artwork->thumbUrl('md') ?? '/images/placeholder.jpg',
            'is_public'       => (bool) $artwork->is_public,
            'visibility'      => $artwork->visibility ?: ((bool) $artwork->is_public ? Artwork::VISIBILITY_PUBLIC : Artwork::VISIBILITY_PRIVATE),
            'is_approved'     => (bool) $artwork->is_approved,
            'published_at'    => $artwork->published_at?->toIso8601String(),
            'publish_at'      => $artwork->publish_at?->toIso8601String(),
            'artwork_status'  => $artwork->artwork_status,
            'created_at'      => $artwork->created_at?->toIso8601String(),
            'deleted_at'      => $artwork->deleted_at?->toIso8601String(),
            'category'        => $artwork->categories->first()?->name,
            'category_slug'   => $artwork->categories->first()?->slug,
            'tags'            => $artwork->tags->pluck('slug')->values()->all(),
            'views'           => (int) ($stats?->views ?? 0),
            'favourites'      => (int) ($stats?->favorites ?? 0),
            'shares'          => (int) ($stats?->shares_count ?? 0),
            'comments'        => (int) ($stats?->comments_count ?? 0),
            'downloads'       => (int) ($stats?->downloads ?? 0),
            'ranking_score'   => (float) ($stats?->ranking_score ?? 0),
            'heat_score'      => (float) ($stats?->heat_score ?? 0),
        ];
    }

    /**
     * GET /api/studio/tags/search?q=...
     * Search active tags for studio pickers, with empty-query fallback to popular tags.
     */
    public function searchTags(Request $request): JsonResponse
    {
        $query = trim((string) $request->input('q'));

        $tags = $this->tagDiscoveryService->searchSuggestions($query, 30);

        return response()->json($tags);
    }

    /**
     * POST /api/studio/artworks/{id}/replace-file
     * Replace the artwork's primary image file — creates a new immutable version.
     *
     * Accepts an optional `change_note` text field alongside the file.
     */
    public function replaceFile(Request $request, int $id): JsonResponse
    {
        $artwork = $request->user()->artworks()->findOrFail($id);

        $request->validate([
            'file'        => 'required|file|mimes:jpeg,jpg,png,webp|max:51200', // 50 MB
            'change_note' => 'sometimes|nullable|string|max:500',
        ]);

        // ── Rate-limit gate (before expensive file processing) ────────────
        try {
            $this->versioningService->rateLimitCheck($request->user()->id, $artwork->id);
        } catch (TooManyRequestsHttpException $e) {
            return response()->json(['success' => false, 'error' => $e->getMessage()], 429);
        }

        $file     = $request->file('file');
        $tempPath = $file->getRealPath();
        $hash     = hash_file('sha256', $tempPath);

        // Reject identical files early (before any disk writes)
        if ($artwork->hash === $hash) {
            return response()->json([
                'success' => false,
                'error'   => 'The uploaded file is identical to the current version.',
            ], 422);
        }

        try {
            $derivatives  = app(\App\Services\Uploads\UploadDerivativesService::class);
            $storage      = app(\App\Services\Uploads\UploadStorageService::class);
            $artworkFiles = app(\App\Repositories\Uploads\ArtworkFileRepository::class);

            // 1. Store original on disk (preserve extension when possible)
            $originalAsset    = $derivatives->storeOriginal($tempPath, $hash);
            $originalPath     = $originalAsset['local_path'];
            $origFilename     = basename($originalPath);
            $originalRelative = $storage->sectionRelativePath('original', $hash, $origFilename);
            $origMime         = File::exists($originalPath) ? File::mimeType($originalPath) : 'application/octet-stream';
            $artworkFiles->upsert($artwork->id, 'orig', $originalRelative, $origMime, (int) filesize($originalPath));

            // 2. Generate thumbnails (xs/sm/md/lg/xl)
            $publicAssets = $derivatives->generatePublicDerivatives($tempPath, $hash);
            foreach ($publicAssets as $variant => $asset) {
                $relativePath = $storage->sectionRelativePath($variant, $hash, $hash . '.webp');
                $artworkFiles->upsert($artwork->id, $variant, $relativePath, 'image/webp', (int) ($asset['size'] ?? 0));
            }

            // 3. Get new dimensions
            $dims   = @getimagesize($tempPath);
            $width  = is_array($dims) && isset($dims[0]) ? (int) $dims[0] : $artwork->width;
            $height = is_array($dims) && isset($dims[1]) ? (int) $dims[1] : $artwork->height;
            $size   = (int) filesize($originalPath);

            // 4. Update the artwork's file-serving fields (hash drives thumbnail URLs)
            $origExt = strtolower(pathinfo($originalPath, PATHINFO_EXTENSION) ?: '');
            $displayFileName = $origFilename;

            $clientName = basename(str_replace('\\', '/', (string) $file->getClientOriginalName()));
            $clientName = preg_replace('/[\x00-\x1F\x7F]/', '', (string) $clientName) ?? '';
            $clientName = trim((string) $clientName);

            if ($clientName !== '') {
                $clientExt = strtolower((string) pathinfo($clientName, PATHINFO_EXTENSION));
                if ($clientExt === '' && $origExt !== '') {
                    $clientName .= '.' . $origExt;
                }

                $displayFileName = $clientName;
            }

            $artwork->update([
                'file_name' => $displayFileName,
                'file_path' => '',
                'file_size' => $size,
                'mime_type' => $origMime,
                'hash'      => $hash,
                'file_ext'  => $origExt,
                'thumb_ext' => 'webp',
                'width'     => max(1, $width),
                'height'    => max(1, $height),
            ]);

            // 5. Create version record, apply ranking protection, audit log
            $version = $this->versioningService->createNewVersion(
                $artwork,
                $originalRelative,
                $hash,
                max(1, $width),
                max(1, $height),
                $size,
                $request->user()->id,
                $request->input('change_note'),
            );

            // 6. Reindex in Meilisearch (non-blocking)
            try {
                $this->searchIndexer->update($artwork);
            } catch (\Throwable $e) {
                Log::warning('ArtworkVersioningService: Meilisearch reindex failed', [
                    'artwork_id' => $artwork->id,
                    'error'      => $e->getMessage(),
                ]);
            }

            // 7. CDN cache bust — purge thumbnail paths for the old hash
            $this->purgeCdnCache($artwork, $hash);

            return response()->json([
                'success'        => true,
                'thumb_url'      => $artwork->thumbUrl('md'),
                'thumb_url_lg'   => $artwork->thumbUrl('lg'),
                'width'          => $artwork->width,
                'height'         => $artwork->height,
                'file_size'      => $artwork->file_size,
                'version_number' => $version->version_number,
                'requires_reapproval' => (bool) $artwork->requires_reapproval,
            ]);
        } catch (\Throwable $e) {
            Log::error('replaceFile: processing error', [
                'artwork_id' => $artwork->id,
                'error'      => $e->getMessage(),
            ]);
            return response()->json(['success' => false, 'error' => 'File processing failed: ' . $e->getMessage()], 500);
        }
    }

    /**
     * GET /api/studio/artworks/{id}/versions
     * Return version history for an artwork (newest first).
     */
    public function versions(Request $request, int $id): JsonResponse
    {
        $artwork  = $request->user()->artworks()->findOrFail($id);
        $versions = $artwork->versions()->reorder()->orderByDesc('version_number')->get();

        return response()->json([
            'artwork' => [
                'id'            => $artwork->id,
                'title'         => $artwork->title,
                'version_count' => (int) ($artwork->version_count ?? 1),
            ],
            'versions' => $versions->map(fn (ArtworkVersion $v) => [
                'id'             => $v->id,
                'version_number' => $v->version_number,
                'file_path'      => $v->file_path,
                'file_hash'      => $v->file_hash,
                'width'          => $v->width,
                'height'         => $v->height,
                'file_size'      => $v->file_size,
                'change_note'    => $v->change_note,
                'is_current'     => $v->is_current,
                'created_at'     => $v->created_at?->toIso8601String(),
            ])->values(),
        ]);
    }

    /**
     * POST /api/studio/artworks/{id}/restore/{version_id}
     * Restore an earlier version (cloned as a new current version).
     */
    public function restoreVersion(Request $request, int $id, int $versionId): JsonResponse
    {
        $artwork = $request->user()->artworks()->findOrFail($id);
        $version = ArtworkVersion::where('artwork_id', $artwork->id)->findOrFail($versionId);

        if ($version->is_current) {
            return response()->json(['success' => false, 'error' => 'This version is already the current version.'], 422);
        }

        try {
            $newVersion = $this->versioningService->restoreVersion($version, $artwork, $request->user()->id);

            // Sync artwork file fields back to restored version dimensions
            $artwork->update([
                'width'     => max(1, (int) $version->width),
                'height'    => max(1, (int) $version->height),
                'file_size' => (int) $version->file_size,
            ]);

            $artwork->refresh();

            // Reindex
            try {
                $this->searchIndexer->update($artwork);
            } catch (\Throwable) {}

            return response()->json([
                'success'        => true,
                'version_number' => $newVersion->version_number,
                'message'        => "Version {$version->version_number} has been restored as version {$newVersion->version_number}.",
            ]);
        } catch (TooManyRequestsHttpException $e) {
            return response()->json(['success' => false, 'error' => $e->getMessage()], 429);
        } catch (\Throwable $e) {
            return response()->json(['success' => false, 'error' => 'Restore failed: ' . $e->getMessage()], 500);
        }
    }

    /**
     * Purge CDN thumbnail cache for the artwork.
     *
     * This is best-effort; failures are logged but never fatal.
     * Configure a CDN purge webhook via ARTWORK_CDN_PURGE_URL if needed.
     */
    private function purgeCdnCache(\App\Models\Artwork $artwork, string $oldHash): void
    {
        try {
            $this->cdnPurge->purgeArtworkHashVariants($oldHash, 'webp', ['xs', 'sm', 'md', 'lg', 'xl', 'sq'], [
                'artwork_id' => $artwork->id,
                'reason' => 'artwork_file_replaced',
            ]);
        } catch (\Throwable $e) {
            Log::warning('CDN cache purge failed', ['artwork_id' => $artwork->id, 'error' => $e->getMessage()]);
        }
    }
}
