SkinbaseNova/app/Services/Uploads/UploadStorageService.php

<?php

declare(strict_types=1);

namespace App\Services\Uploads;

use App\DTOs\Uploads\UploadStoredFile;
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\File;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Str;
use RuntimeException;

final class UploadStorageService
{
    public function localOriginalsRoot(): string
    {
        return rtrim((string) config('uploads.local_originals_root'), DIRECTORY_SEPARATOR);
    }

    public function sectionPath(string $section): string
    {
        $root = rtrim((string) config('uploads.storage_root'), DIRECTORY_SEPARATOR);
        $paths = (array) config('uploads.paths');

        if (! array_key_exists($section, $paths)) {
            throw new RuntimeException('Unknown upload storage section: ' . $section);
        }

        return $root . DIRECTORY_SEPARATOR . trim((string) $paths[$section], DIRECTORY_SEPARATOR);
    }

    public function ensureSection(string $section): string
    {
        $path = $this->sectionPath($section);

        if (! File::exists($path)) {
            File::makeDirectory($path, 0755, true);
        }

        return $path;
    }

    public function storeUploadedFile(UploadedFile $file, string $section): UploadStoredFile
    {
        $dir = $this->ensureSection($section);
        $extension = $this->safeExtension($file);
        $filename = Str::uuid()->toString() . ($extension !== '' ? '.' . $extension : '');

        $file->move($dir, $filename);

        $path = $dir . DIRECTORY_SEPARATOR . $filename;

        return UploadStoredFile::fromPath($path);
    }

    public function moveToSection(string $path, string $section): string
    {
        if (! is_file($path)) {
            throw new RuntimeException('Source file not found for move.');
        }

        $dir = $this->ensureSection($section);
        $extension = (string) pathinfo($path, PATHINFO_EXTENSION);
        $filename = Str::uuid()->toString() . ($extension !== '' ? '.' . $extension : '');
        $target = $dir . DIRECTORY_SEPARATOR . $filename;

        File::move($path, $target);

        return $target;
    }

    public function ensureHashDirectory(string $section, string $hash): string
    {
        $segments = $this->hashSegments($hash);
        $dir = $this->sectionPath($section) . DIRECTORY_SEPARATOR . implode(DIRECTORY_SEPARATOR, $segments);

        if (! File::exists($dir)) {
            File::makeDirectory($dir, 0755, true);
        }

        return $dir;
    }

    public function ensureLocalOriginalHashDirectory(string $hash): string
    {
        $segments = $this->hashSegments($hash);
        $dir = $this->localOriginalsRoot() . DIRECTORY_SEPARATOR . implode(DIRECTORY_SEPARATOR, $segments);

        if (! File::exists($dir)) {
            File::makeDirectory($dir, 0755, true);
        }

        return $dir;
    }

    public function sectionRelativePath(string $section, string $hash, string $filename): string
    {
        $segments = $this->hashSegments($hash);
        $section = trim($section, DIRECTORY_SEPARATOR);

        return $section . '/' . implode('/', $segments) . '/' . ltrim($filename, '/');
    }

    public function localOriginalPath(string $hash, string $filename): string
    {
        return $this->ensureLocalOriginalHashDirectory($hash) . DIRECTORY_SEPARATOR . ltrim($filename, DIRECTORY_SEPARATOR);
    }

    public function objectDiskName(): string
    {
        return (string) config('uploads.object_storage.disk', 's3');
    }

    public function objectBasePrefix(): string
    {
        return trim((string) config('uploads.object_storage.prefix', 'artworks'), '/');
    }

    public function objectPathForVariant(string $variant, string $hash, string $filename): string
    {
        $segments = implode('/', $this->hashSegments($hash));
        $basePrefix = $this->objectBasePrefix();
        $normalizedVariant = trim($variant, '/');

        if ($normalizedVariant === 'original') {
            return sprintf('%s/original/%s/%s', $basePrefix, $segments, ltrim($filename, '/'));
        }

        return sprintf('%s/%s/%s/%s', $basePrefix, $normalizedVariant, $segments, ltrim($filename, '/'));
    }

    public function putObjectFromPath(string $sourcePath, string $objectPath, string $contentType, array $extraOptions = []): void
    {
        $stream = fopen($sourcePath, 'rb');
        if ($stream === false) {
            throw new RuntimeException('Unable to open source file for object storage upload.');
        }

        try {
            $written = Storage::disk($this->objectDiskName())->put($objectPath, $stream, array_merge([
                'visibility' => 'public',
                'CacheControl' => 'public, max-age=31536000, immutable',
                'ContentType' => $contentType,
            ], $extraOptions));
        } finally {
            fclose($stream);
        }

        if ($written !== true) {
            throw new RuntimeException('Object storage upload failed.');
        }
    }

    public function putObjectContents(string $objectPath, string $contents, string $contentType, array $extraOptions = []): void
    {
        $written = Storage::disk($this->objectDiskName())->put($objectPath, $contents, array_merge([
            'visibility' => 'public',
            'CacheControl' => 'public, max-age=31536000, immutable',
            'ContentType' => $contentType,
        ], $extraOptions));

        if ($written !== true) {
            throw new RuntimeException('Object storage upload failed.');
        }
    }

    public function deleteObject(string $objectPath): void
    {
        if ($objectPath === '') {
            return;
        }

        Storage::disk($this->objectDiskName())->delete($objectPath);
    }

    public function readObject(string $objectPath): ?string
    {
        if ($objectPath === '') {
            return null;
        }

        $disk = Storage::disk($this->objectDiskName());
        if (! $disk->exists($objectPath)) {
            return null;
        }

        $contents = $disk->get($objectPath);

        return is_string($contents) && $contents !== '' ? $contents : null;
    }

    public function deleteLocalFile(?string $path): void
    {
        if (! is_string($path) || trim($path) === '') {
            return;
        }

        if (File::exists($path)) {
            File::delete($path);
        }
    }

    public function originalHashExists(string $hash): bool
    {
        $segments = $this->hashSegments($hash);
        $dir = $this->sectionPath('original') . DIRECTORY_SEPARATOR . implode(DIRECTORY_SEPARATOR, $segments);

        if (! File::isDirectory($dir)) {
            return false;
        }

        $normalizedHash = strtolower(preg_replace('/[^a-z0-9]/', '', $hash) ?? '');
        if ($normalizedHash === '') {
            return false;
        }

        $matches = File::glob($dir . DIRECTORY_SEPARATOR . $normalizedHash . '.*');
        return is_array($matches) && count($matches) > 0;
    }

    private function safeExtension(UploadedFile $file): string
    {
        $extension = (string) $file->guessExtension();
        $extension = strtolower($extension);

        return preg_match('/^[a-z0-9]+$/', $extension) ? $extension : '';
    }

    private function hashSegments(string $hash): array
    {
        $hash = strtolower($hash);
        $hash = preg_replace('/[^a-z0-9]/', '', $hash) ?? '';
        $hash = str_pad($hash, 6, '0');

        // Use two 2-char segments for directory sharding: first two chars, next two chars.
        // Result: <section>/<aa>/<bb>/<filename>
        $segments = [
            substr($hash, 0, 2),
            substr($hash, 2, 2),
        ];

        return array_map(static fn (string $part): string => $part === '' ? '00' : $part, $segments);
    }
}