presseportale/app/Services/SearchConsole/IndexStatusReport.php

<?php

namespace App\Services\SearchConsole;

use App\Enums\IndexState;
use App\Enums\Portal;
use App\Models\PressRelease;
use App\Models\PressReleaseIndexCheck;
use App\Scopes\PortalScope;
use App\Services\PressRelease\CanonicalAssigner;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Support\Carbon;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\DB;

/**
 * Admin-Auswertung des Indexierungsstatus (Roadmap 1c.4/1c.5): Verteilung
 * der jüngsten Befunde je Portal, getrennt nach Direkteinreichung und
 * Syndikation über die API. Erst diese Verteilung entscheidet, ob und wie
 * der Status in die Kundenansicht kommt (E8).
 */
class IndexStatusReport
{
    /**
     * Ausdruck, der eine Meldung der Herkunft „api" oder „direct" zuordnet:
     * Marker ist ein Status-Log-Eintrag mit Quelle „api" (wie beim
     * Mail-Versand — der Kontotyp ist nicht verlässlich). Erwartet den
     * Join aus apiJoin(): als Join ein Bruchteil der Laufzeit eines
     * korrelierten EXISTS über den Bestand (0,3 s statt 2,6 s).
     */
    private const string ORIGIN_SQL = "case when api_origin.press_release_id is null then 'direct' else 'api' end";

    private const int CACHE_SECONDS = 900;

    /** @var list<string> */
    public const array ORIGINS = ['direct', 'api'];

    /** @var list<string> */
    public const array ROLES = ['source', 'copy'];

    /**
     * Anzahl der Meldungen je Portal, Herkunft, Rolle und Befund — Stand der
     * jeweils jüngsten Prüfung. Meldungen ohne Prüfung erscheinen unter
     * `unchecked`.
     *
     * @return array<string, array<string, array<string, array<string, int>>>> portal => origin => role => state|unchecked|total => count
     */
    public function distribution(): array
    {
        return Cache::remember('index-status.distribution', self::CACHE_SECONDS, fn (): array => $this->computeDistribution());
    }

    /**
     * @return array<string, array<string, array<string, array<string, int>>>>
     */
    private function computeDistribution(): array
    {
        $rows = [];

        foreach ([Portal::Presseecho, Portal::Businessportal24] as $portal) {
            $roleSql = $this->roleSql($portal);

            // Herkunft und Rolle je Meldung erst in einer abgeleiteten Tabelle
            // bestimmen, dann darüber gruppieren — MySQL (only_full_group_by)
            // lehnt den korrelierten Ausdruck direkt im GROUP BY ab.
            $visible = DB::query()
                ->fromSub(
                    $this->apiJoin($this->visibleOn($portal))
                        ->selectRaw('press_releases.id, '.self::ORIGIN_SQL.' as origin, '.$roleSql.' as role'),
                    'r'
                )
                ->selectRaw('origin, role, count(*) as total')
                ->groupBy('origin', 'role')
                ->get();

            // Dieselbe Grundgesamtheit wie `total`: nur Checks von Meldungen,
            // die auf diesem Portal gerade sichtbar sind — sonst zählt eine
            // inzwischen depublizierte oder entfernte Meldung als „indexed",
            // ohne im Nenner zu stehen.
            $checked = DB::query()
                ->fromSub(
                    $this->apiJoin($this->latestChecks($portal)
                        ->join('press_releases', 'press_releases.id', '=', 'press_release_index_checks.press_release_id')
                        ->whereIn('press_releases.id', $this->visibleOn($portal)->select('press_releases.id')))
                        ->selectRaw('press_release_index_checks.id, press_release_index_checks.state, '.self::ORIGIN_SQL.' as origin, '.$roleSql.' as role'),
                    'c'
                )
                ->selectRaw('origin, role, state, count(*) as total')
                ->groupBy('origin', 'role', 'state')
                ->get();

            foreach (self::ORIGINS as $origin) {
                foreach (self::ROLES as $role) {
                    $bucket = ['total' => 0, 'unchecked' => 0];

                    foreach (IndexState::cases() as $state) {
                        $bucket[$state->value] = 0;
                    }

                    $bucket['total'] = (int) ($visible->first(fn (object $row): bool => $row->origin === $origin && $row->role === $role)->total ?? 0);

                    $checkedTotal = 0;

                    foreach ($checked->filter(fn (object $row): bool => $row->origin === $origin && $row->role === $role) as $row) {
                        $bucket[(string) $row->state] = (int) $row->total;
                        $checkedTotal += (int) $row->total;
                    }

                    $bucket['unchecked'] = max(0, $bucket['total'] - $checkedTotal);
                    $rows[$portal->value][$origin][$role] = $bucket;
                }
            }
        }

        return $rows;
    }

    /**
     * Quellenbefund (1c.9) über die jüngsten Prüfungen je Portal: welche
     * Adresse Google als maßgeblich führt — diese, die eigene Fassung auf dem
     * anderen Portal, ein fremdes Portal, oder keine Angabe. Nur Erstquellen
     * (1c.8) zählen: bei einer Kopie ist die Abweichung gewollt.
     *
     * @return array<string, array{self: int, own_other: int, foreign: int, unknown: int, total: int, foreign_hosts: array<string, int>}>
     */
    public function sourceSummary(IndexStatusChecker $checker): array
    {
        return Cache::remember('index-status.sources', self::CACHE_SECONDS, fn (): array => $this->computeSourceSummary($checker));
    }

    /**
     * @return array<string, array{self: int, own_other: int, foreign: int, unknown: int, total: int, foreign_hosts: array<string, int>}>
     */
    private function computeSourceSummary(IndexStatusChecker $checker): array
    {
        $summary = [];

        foreach ([Portal::Presseecho, Portal::Businessportal24] as $portal) {
            $bucket = ['self' => 0, 'own_other' => 0, 'foreign' => 0, 'unknown' => 0, 'total' => 0, 'foreign_hosts' => []];

            $this->latestChecks($portal)
                ->join('press_releases', 'press_releases.id', '=', 'press_release_index_checks.press_release_id')
                ->whereNull('press_releases.deleted_at')
                ->whereNull('press_releases.canonical_press_release_id')
                ->select(['press_release_index_checks.id', 'press_release_index_checks.url', 'press_release_index_checks.google_canonical', 'press_release_index_checks.portal'])
                ->lazyById(1000, 'press_release_index_checks.id', 'id')
                ->each(function (PressReleaseIndexCheck $check) use (&$bucket, $checker): void {
                    $verdict = $checker->sourceVerdict($check);
                    $bucket[$verdict['kind']]++;
                    $bucket['total']++;

                    if ($verdict['kind'] === 'foreign' && $verdict['host'] !== null) {
                        $bucket['foreign_hosts'][$verdict['host']] = ($bucket['foreign_hosts'][$verdict['host']] ?? 0) + 1;
                    }
                });

            arsort($bucket['foreign_hosts']);
            $bucket['foreign_hosts'] = array_slice($bucket['foreign_hosts'], 0, 10, true);
            $summary[$portal->value] = $bucket;
        }

        return $summary;
    }

    /**
     * Jüngste Prüfungen, neueste zuerst.
     *
     * @return Collection<int, PressReleaseIndexCheck>
     */
    public function latest(int $limit = 100): Collection
    {
        return PressReleaseIndexCheck::query()
            ->with(['pressRelease' => fn ($query) => $query->withoutGlobalScopes()->select(['id', 'title', 'slug', 'published_at', 'canonical_press_release_id'])])
            ->orderByDesc('checked_at')
            ->orderByDesc('id')
            ->limit($limit)
            ->get();
    }

    public function lastCheckedAt(): ?Carbon
    {
        $value = PressReleaseIndexCheck::query()->max('checked_at');

        return $value ? Carbon::parse((string) $value) : null;
    }

    /**
     * Herkunftsmarker als Join: alle Meldungen, die je einen Status-Log-
     * Eintrag mit Quelle „api" haben.
     *
     * @template TModel of \Illuminate\Database\Eloquent\Model
     *
     * @param  Builder<TModel>  $query
     * @return Builder<TModel>
     */
    /**
     * Rolle einer Meldung auf `$portal` in der kanonischen Zuordnung (1c.8):
     * Erstquelle oder Kopie mit rel=canonical auf die andere Fassung. Für
     * eine Kopie ist „ausgeschlossen" (Google folgt dem Verweis) der
     * erwartete Befund. Dieselbe Regel wie CanonicalAssigner::isCanonicalOn()
     * und damit die Sitemap: Ohne Freigabe ist alles Erstquelle; eine
     * Meldung mit portal=both ist nur auf dem Portal ihrer Kategorie
     * Erstquelle, auf dem anderen Kopie (Umsetzungsaudit 29.09.2026,
     * N18-Rest).
     */
    private function roleSql(Portal $portal): string
    {
        $assigner = app(CanonicalAssigner::class);

        if (! $assigner->enabled()) {
            return "'source'";
        }

        $other = $portal === Portal::Presseecho ? Portal::Businessportal24 : Portal::Presseecho;
        $foreignCategories = array_map('intval', $assigner->categoryIdsPreferring($other));
        $bothOnOtherPortal = $foreignCategories === []
            ? ''
            : " when press_releases.portal = '".Portal::Both->value."' and press_releases.category_id in (".implode(',', $foreignCategories).") then 'copy'";

        return "case when press_releases.canonical_press_release_id is not null then 'copy'".$bothOnOtherPortal." else 'source' end";
    }

    private function apiJoin(Builder $query): Builder
    {
        $api = DB::table('press_release_status_logs')
            ->select('press_release_id')
            ->where('source', 'api')
            ->distinct();

        return $query->leftJoinSub($api, 'api_origin', 'api_origin.press_release_id', '=', 'press_releases.id');
    }

    /**
     * Auf dem Portal gerade sichtbare Meldungen — die Grundgesamtheit von
     * `total` und der Zustandszählung.
     *
     * @return Builder<PressRelease>
     */
    private function visibleOn(Portal $portal): Builder
    {
        return PressRelease::query()
            ->withoutGlobalScope(PortalScope::class)
            ->visibleInArchive()
            ->forPortalValues([$portal->value, Portal::Both->value]);
    }

    /**
     * Jeweils jüngste Prüfung je Meldung auf einem Portal. Bestimmt über die
     * höchste ID, nicht über `max(checked_at)`: zwei Prüfungen in derselben
     * Sekunde hätten sonst beide gezählt.
     *
     * @return Builder<PressReleaseIndexCheck>
     */
    private function latestChecks(Portal $portal): Builder
    {
        $latest = PressReleaseIndexCheck::query()
            ->select('press_release_id', DB::raw('max(id) as last_id'))
            ->where('portal', $portal->value)
            ->groupBy('press_release_id');

        return PressReleaseIndexCheck::query()
            ->joinSub($latest, 'latest', fn ($join) => $join
                ->on('latest.last_id', '=', 'press_release_index_checks.id'))
            ->where('press_release_index_checks.portal', $portal->value);
    }
}