<?php

namespace App\Jobs;

use App\Enums\PressReleaseContentTier;
use App\Models\KiAudit;
use App\Models\PressRelease;
use App\Scopes\PortalScope;
use App\Services\PressRelease\ContentScore\ContentScoreManager;
use App\Services\PressRelease\ContentScore\ContentScoreResult;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Queue\Queueable;
use Illuminate\Support\Facades\Log;

/**
 * Berechnet den Content-Score einer Pressemitteilung asynchron (Konzept §15.2).
 *
 * Läuft auf der Queue „classification" (gemeinsam mit der Klassifikation, ein
 * Drain-Befehl). Nutzt den konfigurierten Treiber; bei Ausfall greift der
 * deterministische Fallback. Ergebnis: `content_score` + abgeleitete
 * `content_tier` + `scored_at`, plus `ki_audits`-Eintrag (type=content_score).
 *
 * Reine Qualitätsbewertung – ändert nie den Status (das macht die
 * Klassifikation).
 *
 * Inhaltsbindung wie bei ClassifyPressRelease (Audit F07): Ergebnis für
 * einen inzwischen geänderten Text wird verworfen und neu eingeplant.
 */
class ScorePressRelease implements ShouldQueue
{
    use Queueable;

    public int $tries = 3;

    /**
     * Drei HTTP-Versuche à 30 s plus Verbindungsaufbau (~91 s) überschreiten
     * die 60 s des Workers – der deterministische Fallback käme sonst nie
     * zum Zug (Audit F17). retry_after (config/queue.php) liegt darüber.
     */
    public int $timeout = 120;

    public function __construct(
        public readonly int $pressReleaseId,
        public readonly ?string $providerOverride = null,
        public readonly ?string $contentHash = null,
    ) {}

    public function handle(ContentScoreManager $manager): void
    {
        $pressRelease = PressRelease::withoutGlobalScope(PortalScope::class)->find($this->pressReleaseId);

        if ($pressRelease === null) {
            return;
        }

        $analyzedHash = $this->contentHash ?? $pressRelease->content_hash;
        $result = $this->score($manager, $pressRelease);
        $tier = PressReleaseContentTier::fromScore($result->score);

        $currentHash = PressRelease::withoutGlobalScope(PortalScope::class)->whereKey($pressRelease->id)->value('content_hash');

        if ($analyzedHash !== null && $currentHash !== null && $currentHash !== $analyzedHash) {
            KiAudit::query()->create([
                'press_release_id' => $pressRelease->id,
                'type' => KiAudit::TYPE_CONTENT_SCORE,
                'provider' => $result->provider,
                'model' => $result->model,
                'result' => (string) $result->score,
                'reason' => 'Verworfen: Inhalt wurde während der Bewertung geändert.',
                'raw_response' => ['breakdown' => $result->breakdown] + $result->rawResponse,
                'content_hash' => $analyzedHash,
                'discarded_at' => now(),
                'created_at' => now(),
            ]);

            self::dispatch($pressRelease->id, $this->providerOverride, $currentHash)->onQueue('classification');

            return;
        }

        $pressRelease->forceFill([
            'content_score' => $result->score,
            'content_tier' => $tier->value,
            'scored_at' => now(),
        ])->save();

        KiAudit::query()->create([
            'press_release_id' => $pressRelease->id,
            'type' => KiAudit::TYPE_CONTENT_SCORE,
            'provider' => $result->provider,
            'model' => $result->model,
            'result' => (string) $result->score,
            'reason' => $tier->label(),
            'raw_response' => ['breakdown' => $result->breakdown] + $result->rawResponse,
            'content_hash' => $analyzedHash,
            'created_at' => now(),
        ]);
    }

    /**
     * Bewertet über den aktiven (oder explizit gewählten) Treiber; bei Fehler
     * greift der deterministische Fallback.
     */
    private function score(ContentScoreManager $manager, PressRelease $pressRelease): ContentScoreResult
    {
        $provider = $this->providerOverride ?: $manager->getDefaultDriver();

        try {
            return $manager->driver($provider)->score($pressRelease);
        } catch (\Throwable $exception) {
            Log::warning('Content-Score fiel auf den deterministischen Treiber zurück.', [
                'press_release_id' => $pressRelease->id,
                'provider' => $provider,
                'error' => $exception->getMessage(),
            ]);

            return $manager->driver('deterministic')->score($pressRelease);
        }
    }
}