<?php

declare(strict_types=1);

namespace DomainWarn\WordPress\Service;

/**
 * Woher die Datei kommt, die die Website unter /.well-known/security.txt selbst ausgibt: von DomainWarn geholt, eine
 * Stunde zwischengespeichert, und bei einem Ausfall von DomainWarn die zuletzt gute Fassung – aber nur, solange deren
 * Expires in der Zukunft liegt. Eine abgelaufene security.txt ist nach RFC 9116 ungültig; dann lieber gar keine.
 *
 * Kommt nichts Brauchbares, gibt es null: Die Website antwortet dann so, als gäbe es die Erweiterung nicht, statt eine
 * leere oder kaputte Datei auszuliefern.
 *
 * Diese Klasse ist bewusst dieselbe wie in der Shopware-Erweiterung.
 */
final readonly class SecurityTxtSource
{
    /** So lange gilt eine geholte Datei; so lange dürfen auch Browser und Zwischenspeicher sie behalten. */
    public const CACHE_SECONDS = 3600;

    /** Nach einem gescheiterten Abruf so lange nicht erneut fragen (bis dahin: Rückfall oder nichts). */
    public const RETRY_SECONDS = 300;

    public function __construct(private HttpTransport $transport, private SecurityTxtStore $store) {}

    /**
     * Die auszuliefernde Datei für dieses Ziel, byte-genau wie von DomainWarn, oder null. Das Ziel muss vorher gegen
     * die Basis geprüft sein (SiteHosting::target).
     */
    public function body(string $target, int $now): ?string
    {
        $cached = $this->store->cached($target);
        if ($cached !== null && $cached['until'] > $now) {
            return $cached['body'] !== null && SecurityTxtFile::plausible($cached['body']) ? $cached['body'] : null;
        }
        try {
            $response = $this->transport->request('GET', $target, ['Accept' => 'text/plain']);
        } catch (TransportException) {
            $response = null;
        }
        $body = $response !== null ? SecurityTxtFile::fromResponse($response) : null;
        if ($body !== null) {
            $this->store->saveCached($target, $body, $now + self::CACHE_SECONDS);
            // nur schreiben, was sich geändert hat – die Ablage ist dauerhaft und soll nicht stündlich neu entstehen
            if ($this->store->lastGood($target) !== $body) {
                $this->store->saveLastGood($target, $body);
            }

            return $body;
        }
        if ($response !== null && in_array($response->status, [404, 410], true)) {
            // DomainWarn sagt ausdrücklich „keine Datei“: Die Auslieferung ist abgeschaltet – dann auch keine alte Fassung
            $this->store->saveLastGood($target, null);
            $this->store->saveCached($target, null, $now + self::RETRY_SECONDS);

            return null;
        }
        // nicht erreichbar, überlastet (429, 5xx) oder eine Antwort, die keine security.txt ist: Rückfall
        $fallback = $this->fallback($target, $now);
        $expires = $fallback !== null ? (int) SecurityTxtFile::expires($fallback) : 0;
        $this->store->saveCached($target, $fallback, $fallback !== null ? min($now + self::RETRY_SECONDS, $expires) : $now + self::RETRY_SECONDS);

        return $fallback;
    }

    /** Den Zwischenspeicher leeren; die letzte gute Fassung bleibt. */
    public function forget(): void
    {
        $this->store->forgetCached();
    }

    /** Die zuletzt gute Fassung, wenn sie noch nicht abgelaufen ist. */
    private function fallback(string $target, int $now): ?string
    {
        $body = $this->store->lastGood($target);
        if ($body === null || ! SecurityTxtFile::plausible($body)) {
            return null;
        }
        $expires = SecurityTxtFile::expires($body);

        return $expires !== null && $expires > $now ? $body : null;
    }
}