<?php

declare(strict_types=1);

namespace App\Services\Enhance;

use App\Models\Artwork;
use App\Models\EnhanceJob;
use App\Models\User;
use App\Services\ArtworkOriginalFileLocator;
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Str;
use Intervention\Image\Drivers\Gd\Driver as GdDriver;
use Intervention\Image\Drivers\Imagick\Driver as ImagickDriver;
use Intervention\Image\Encoders\WebpEncoder;
use Intervention\Image\ImageManager;
use RuntimeException;

final class EnhanceStorageService
{
    private ?ImageManager $manager = null;

    public function __construct(
        private readonly ArtworkOriginalFileLocator $artworkOriginalFileLocator,
    ) {
        try {
            $this->manager = extension_loaded('gd')
                ? new ImageManager(new GdDriver())
                : new ImageManager(new ImagickDriver());
        } catch (\Throwable) {
            $this->manager = null;
        }
    }

    public function diskName(): string
    {
        return (string) config('enhance.disk', 'public');
    }

    public function fetchSourceBinary(EnhanceJob $job): string
    {
        $path = trim((string) $job->source_path);

        if ($path === '') {
            throw new RuntimeException('Enhance source image is missing.');
        }

        $contents = Storage::disk($job->source_disk ?: $this->diskName())->get($path);

        if (! is_string($contents) || $contents === '') {
            throw new RuntimeException('Unable to read enhance source image.');
        }

        return $contents;
    }

    public function fetchArtworkSource(Artwork $artwork): array
    {
        $objectPath = $this->artworkOriginalFileLocator->resolveObjectPath($artwork);

        if ($objectPath === '') {
            throw new RuntimeException('Artwork source file is unavailable for enhance.');
        }

        $disk = (string) config('uploads.object_storage.disk', 's3');
        $contents = Storage::disk($disk)->get($objectPath);

        if (! is_string($contents) || $contents === '') {
            throw new RuntimeException('Unable to read the original artwork source.');
        }

        $extension = strtolower(ltrim((string) ($artwork->file_ext ?? pathinfo($objectPath, PATHINFO_EXTENSION)), '.'));
        $mime = trim(strtolower((string) ($artwork->mime_type ?? '')));

        if ($mime === '') {
            $finfo = new \finfo(FILEINFO_MIME_TYPE);
            $mime = strtolower((string) $finfo->buffer($contents));
        }

        return [
            'disk' => $disk,
            'path' => $objectPath,
            'binary' => $contents,
            'mime' => $mime,
            'extension' => $extension !== '' ? $extension : $this->extensionFromMime($mime),
        ];
    }

    public function storeUploadedSource(User $user, UploadedFile $file): array
    {
        $path = (string) ($file->getRealPath() ?: $file->getPathname());

        if ($path === '' || ! is_readable($path)) {
            throw new RuntimeException('Unable to resolve uploaded source path.');
        }

        $binary = file_get_contents($path);

        if (! is_string($binary) || $binary === '') {
            throw new RuntimeException('Unable to read uploaded source image.');
        }

        $extension = strtolower(ltrim((string) ($file->getClientOriginalExtension() ?: $file->extension()), '.'));

        return $this->storeSourceBinary($user, $binary, $extension !== '' ? $extension : 'bin');
    }

    public function storeSourceBinary(User $user, string $binary, string $extension): array
    {
        $finfo = new \finfo(FILEINFO_MIME_TYPE);
        $mime = strtolower((string) $finfo->buffer($binary));
        $normalizedExtension = $extension !== '' ? $extension : $this->extensionFromMime($mime);
        $relativePath = $this->buildPath((string) config('enhance.source_prefix', 'enhance/sources'), (int) $user->id, sprintf('%s.%s', Str::uuid()->toString(), $normalizedExtension));

        $this->writeBinary($this->diskName(), $relativePath, $binary, $mime);

        return [
            'source_disk' => $this->diskName(),
            'source_path' => $relativePath,
            'source_hash' => hash('sha256', $binary),
        ];
    }

    public function putOutputBinary(EnhanceJob $job, string $binary, string $mime, ?string $extension = null): array
    {
        $normalizedMime = strtolower(trim($mime));
        $ext = $extension !== null && $extension !== '' ? strtolower(ltrim($extension, '.')) : $this->extensionFromMime($normalizedMime);
        $filename = sprintf('%s_x%d.%s', Str::uuid()->toString(), (int) $job->scale, $ext);
        $relativePath = $this->buildPath((string) config('enhance.output_prefix', 'enhance/outputs'), (int) $job->user_id, $filename);

        $this->writeBinary($this->diskName(), $relativePath, $binary, $normalizedMime);
        $dimensions = @getimagesizefromstring($binary) ?: [0, 0];

        return [
            'disk' => $this->diskName(),
            'path' => $relativePath,
            'hash' => hash('sha256', $binary),
            'width' => (int) ($dimensions[0] ?? 0),
            'height' => (int) ($dimensions[1] ?? 0),
            'filesize' => strlen($binary),
            'mime' => $normalizedMime,
        ];
    }

    public function storePreviewFromBinary(EnhanceJob $job, string $binary): ?array
    {
        $previewBinary = $binary;
        $previewMime = 'image/webp';

        if ($this->manager !== null) {
            try {
                $previewBinary = (string) $this->manager
                    ->read($binary)
                    ->scaleDown(width: 1600, height: 1600)
                    ->encode(new WebpEncoder(82));
            } catch (\Throwable) {
                $previewMime = strtolower((string) ((new \finfo(FILEINFO_MIME_TYPE))->buffer($binary) ?: 'image/jpeg'));
                $previewBinary = $binary;
            }
        } else {
            $previewMime = strtolower((string) ((new \finfo(FILEINFO_MIME_TYPE))->buffer($binary) ?: 'image/jpeg'));
        }

        $extension = $this->extensionFromMime($previewMime);
        $relativePath = $this->buildPath(
            (string) config('enhance.preview_prefix', 'enhance/previews'),
            (int) $job->user_id,
            sprintf('%s_preview.%s', Str::uuid()->toString(), $extension),
        );

        $this->writeBinary($this->diskName(), $relativePath, $previewBinary, $previewMime);

        return [
            'preview_disk' => $this->diskName(),
            'preview_path' => $relativePath,
        ];
    }

    public function createPreviewFromStoredOutput(EnhanceJob $job, string $disk, string $path): ?array
    {
        $contents = Storage::disk($disk)->get($path);

        if (! is_string($contents) || $contents === '') {
            return null;
        }

        return $this->storePreviewFromBinary($job, $contents);
    }

    public function deleteFiles(EnhanceJob $job): void
    {
        $this->deleteFilesForJob($job);
    }

    public function deleteGeneratedFiles(EnhanceJob $job): void
    {
        foreach ([
            [$job->output_disk, $job->output_path],
            [$job->preview_disk, $job->preview_path],
        ] as [$disk, $path]) {
            $this->safeDelete($disk, $path);
        }
    }

    public function deleteFilesForJob(EnhanceJob $job): array
    {
        $result = [
            'deleted' => [
                'source' => false,
                'output' => false,
                'preview' => false,
            ],
            'skipped' => [],
            'errors' => [],
        ];

        foreach ([
            'source' => [$job->source_disk, $job->source_path],
            'output' => [$job->output_disk, $job->output_path],
            'preview' => [$job->preview_disk, $job->preview_path],
        ] as $key => [$disk, $path]) {
            try {
                $deleted = $this->safeDelete($disk, $path);
                $result['deleted'][$key] = $deleted;

                if (! $deleted && trim((string) $path) !== '') {
                    $result['skipped'][] = $key;
                }
            } catch (\Throwable $exception) {
                $result['errors'][$key] = $exception->getMessage();

                Log::warning('enhance.cleanup.file_delete_failed', [
                    'path' => trim((string) $path),
                    'disk' => $disk ?: $this->diskName(),
                    'message' => $exception->getMessage(),
                ]);
            }
        }

        return $result;
    }

    public function isEnhancePath(?string $path): bool
    {
        $trimmedPath = ltrim(trim((string) $path), '/');

        if ($trimmedPath === '') {
            return false;
        }

        foreach ($this->enhancePrefixes() as $prefix) {
            if ($trimmedPath === $prefix || str_starts_with($trimmedPath, $prefix . '/')) {
                return true;
            }
        }

        return false;
    }

    public function safeDelete(?string $disk, ?string $path): bool
    {
        $trimmedPath = ltrim(trim((string) $path), '/');

        if ($trimmedPath === '') {
            return false;
        }

        if (! $this->isEnhancePath($trimmedPath)) {
            Log::warning('enhance.cleanup.file_skipped', [
                'path' => $trimmedPath,
                'disk' => $disk ?: $this->diskName(),
                'reason' => 'outside-enhance-prefixes',
            ]);

            return false;
        }

        $targetDisk = $disk ?: $this->diskName();

        if (! Storage::disk($targetDisk)->exists($trimmedPath)) {
            return false;
        }

        $deleted = Storage::disk($targetDisk)->delete($trimmedPath);

        if ($deleted) {
            Log::info('enhance.cleanup.file_deleted', [
                'path' => $trimmedPath,
                'disk' => $targetDisk,
            ]);

            return true;
        }

        Log::warning('enhance.cleanup.file_delete_failed', [
            'path' => $trimmedPath,
            'disk' => $targetDisk,
            'message' => 'Storage delete returned false.',
        ]);

        return false;
    }

    public function listKnownJobPaths(): array
    {
        return EnhanceJob::withTrashed()
            ->get(['source_path', 'output_path', 'preview_path'])
            ->flatMap(fn (EnhanceJob $job): array => array_values(array_filter([
                ltrim(trim((string) $job->source_path), '/'),
                ltrim(trim((string) $job->output_path), '/'),
                ltrim(trim((string) $job->preview_path), '/'),
            ])))
            ->unique()
            ->values()
            ->all();
    }

    private function buildPath(string $prefix, int $userId, string $filename): string
    {
        return sprintf(
            '%s/%d/%s/%s/%s',
            trim($prefix, '/'),
            $userId,
            now()->format('Y'),
            now()->format('m'),
            ltrim($filename, '/'),
        );
    }

    private function enhancePrefixes(): array
    {
        return array_values(array_filter(array_unique(array_map(
            static fn (string $prefix): string => trim($prefix, '/'),
            [
                (string) config('enhance.source_prefix', 'enhance/sources'),
                (string) config('enhance.output_prefix', 'enhance/outputs'),
                (string) config('enhance.preview_prefix', 'enhance/previews'),
            ],
        ))));
    }

    private function extensionFromMime(string $mime): string
    {
        return match ($mime) {
            'image/jpeg' => 'jpg',
            'image/png' => 'png',
            'image/webp' => 'webp',
            default => 'bin',
        };
    }

    private function writeBinary(string $disk, string $path, string $binary, string $mime): void
    {
        $written = Storage::disk($disk)->put($path, $binary, [
            'visibility' => 'public',
            'CacheControl' => 'public, max-age=31536000, immutable',
            'ContentType' => $mime,
        ]);

        if ($written !== true) {
            throw new RuntimeException('Unable to store enhance image in storage.');
        }
    }
}