presseportale/app/Models/PressReleaseImage.php

<?php

namespace App\Models;

use App\Enums\AiDeclarationSource;
use App\Enums\AiImageDeclaration;
use App\Enums\CreditSource;
use App\Enums\ImageLicenseType;
use App\Enums\ImageProvenanceStatus;
use Database\Factories\PressReleaseImageFactory;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\MorphMany;
use Illuminate\Database\Eloquent\Relations\MorphOne;
use Illuminate\Database\Eloquent\SoftDeletes;
use Illuminate\Support\Facades\URL;

/**
 * Bild einer Pressemitteilung. Seit Formular v2 (Bildkennzeichnung,
 * 22.09.2026) gilt: `ai_declaration` ist die öffentliche Portalkennzeichnung,
 * `ai_declaration_user` die Angabe des Einreichers, `ai_declaration_source`
 * sagt, woher die Portalkennzeichnung stammt. `rules_version` NULL markiert
 * den Bestand vor der Umstellung; solche Bilder haben kein Beweisoriginal
 * und kein Bestätigungsprotokoll.
 */
class PressReleaseImage extends Model
{
    /** @use HasFactory<PressReleaseImageFactory> */
    use HasFactory;

    use SoftDeletes;

    protected $fillable = [
        'press_release_id',
        'disk',
        'path',
        'variants',
        'title',
        'description',
        'copyright',
        'author',
        'license_type',
        'license_detail',
        'license_url',
        'source_url',
        'persons_consent',
        'people_rights_status',
        'property_rights_status',
        'rights_notes',
        'rights_confirmed_at',
        'is_ai_generated',
        'ai_declaration',
        'ai_declaration_user',
        'ai_declaration_source',
        'ai_declaration_locked',
        'credit_source',
        'provenance_status',
        'provenance',
        'provenance_checked_at',
        'provenance_tool_version',
        'original_disk',
        'original_path',
        'original_sha256',
        'published_snapshot_path',
        'published_snapshot_sha256',
        'published_ever_at',
        'customer_confirmation_requested_at',
        'rules_version',
        'focus_x',
        'focus_y',
        'no_crop',
        'is_preview',
        'sort_order',
        'width',
        'height',
        'mime',
        'legacy_portal',
        'legacy_id',
    ];

    protected function casts(): array
    {
        return [
            'variants' => 'array',
            'license_type' => ImageLicenseType::class,
            'persons_consent' => 'boolean',
            'rights_confirmed_at' => 'datetime',
            'is_ai_generated' => 'boolean',
            'ai_declaration' => AiImageDeclaration::class,
            'ai_declaration_user' => AiImageDeclaration::class,
            'ai_declaration_source' => AiDeclarationSource::class,
            'ai_declaration_locked' => 'boolean',
            'credit_source' => CreditSource::class,
            'provenance_status' => ImageProvenanceStatus::class,
            'provenance' => 'array',
            'provenance_checked_at' => 'datetime',
            'published_ever_at' => 'datetime',
            'customer_confirmation_requested_at' => 'datetime',
            'focus_x' => 'integer',
            'focus_y' => 'integer',
            'no_crop' => 'boolean',
            'is_preview' => 'boolean',
            'sort_order' => 'integer',
            'width' => 'integer',
            'height' => 'integer',
            'deleted_at' => 'datetime',
        ];
    }

    /**
     * @return BelongsTo<PressRelease, $this>
     */
    public function pressRelease(): BelongsTo
    {
        return $this->belongsTo(PressRelease::class);
    }

    /**
     * @return MorphMany<ImageRightsConfirmation, $this>
     */
    public function rightsConfirmations(): MorphMany
    {
        return $this->morphMany(ImageRightsConfirmation::class, 'subject');
    }

    /**
     * @return MorphOne<ImageRightsConfirmation, $this>
     */
    public function latestRightsConfirmation(): MorphOne
    {
        return $this->morphOne(ImageRightsConfirmation::class, 'subject')->latestOfMany('confirmed_at');
    }

    /**
     * Bestand vor Formular v2: kein Beweisoriginal, kein Protokoll. Nach der
     * Legacy-Bereinigung (E.5) sind das nur noch Bilder veröffentlichter PMs.
     */
    public function isLegacyRules(): bool
    {
        return $this->rules_version === null;
    }

    /**
     * Eine Bestätigung zählt nur, wenn sie zur aktuellen Datei gehört
     * (Feedback F09): Bildtausch verlangt eine neue Bestätigung.
     */
    public function hasValidRightsConfirmation(): bool
    {
        $confirmation = $this->relationLoaded('latestRightsConfirmation')
            ? $this->latestRightsConfirmation
            : $this->latestRightsConfirmation()->first();

        return $confirmation !== null
            && $this->original_sha256 !== null
            && hash_equals($this->original_sha256, (string) $confirmation->file_sha256);
    }

    /**
     * Admin-Upload, dessen Kundenbestätigung per Magic-Link noch aussteht
     * (Decision-Update E10). Blockiert die Veröffentlichung (E.1).
     */
    public function awaitsCustomerConfirmation(): bool
    {
        return $this->customer_confirmation_requested_at !== null && ! $this->hasValidRightsConfirmation();
    }

    public function wasEverPublished(): bool
    {
        return $this->published_ever_at !== null;
    }

    public function url(bool $signed = false): ?string
    {
        if (blank($this->path)) {
            return null;
        }

        return $this->resolveDiskUrl($this->path, signed: $signed);
    }

    public function variantUrl(string $key, bool $signed = false): ?string
    {
        $variantPath = $this->pathForVariant($key);

        if (! is_string($variantPath) || blank($variantPath)) {
            return null;
        }

        return $this->resolveDiskUrl($variantPath, $key, $signed);
    }

    public function pathForVariant(?string $key = null): ?string
    {
        if ($key === null || $key === 'original') {
            return $this->path;
        }

        $variants = $this->getAttribute('variants');

        return is_array($variants) && is_string($variants[$key] ?? null)
            ? $variants[$key]
            : null;
    }

    /**
     * Löst die URL je nach Disk auf: public → direkt, sonst über die geschützte
     * Media-Route. `signed=true` erzeugt eine temporär signierte Route, damit
     * die anonyme Token-Vorschau (unveröffentlichte PM) die Bilder laden kann,
     * ohne die Media-Route generell zu öffnen.
     */
    private function resolveDiskUrl(string $relativePath, ?string $variant = null, bool $signed = false): string
    {
        if ($this->disk === 'public') {
            return asset('storage/'.ltrim($relativePath, '/'));
        }

        $parameters = array_filter([
            'image' => $this->getKey(),
            'variant' => $variant,
        ]);

        if ($signed) {
            return URL::temporarySignedRoute('media.press-release-images.show', now()->addHours(6), $parameters);
        }

        return route('media.press-release-images.show', $parameters);
    }
}