<?php

namespace App\Ops;

use Symfony\Component\DependencyInjection\Attribute\Autowire;
use Symfony\Component\Mailer\Exception\TransportExceptionInterface;
use Symfony\Component\Mailer\Transport\Dsn;
use Symfony\Component\Mailer\Transport\TransportInterface;
use Symfony\Component\Mime\Email;

/**
 * Versand mit Protokoll (ADR 121).
 *
 * huefner-gartenbau.de am 12.10.2026: zwei Anfragen „Nicht versendet“, und nirgends stand,
 * warum. Der Formularversand hat die Ausnahme verschluckt; die Ursache - sendmail, das der Hoster
 * so nicht anbietet, ein falsches SMTP-Passwort, ein Absender, den der Server nicht annimmt -
 * blieb Raten. Jetzt geht jeder Versand durch diese Klasse: Formular und Testmail aus der
 * Verwaltung. Sie schreibt eine Zeile nach var/log/mail.log (per FTP lesbar) mit Meldung, einem
 * Hinweis auf Deutsch und den Antworten des Servers.
 *
 * Aus dem SMTP-Gespräch bleiben nur die Zeilen des Servers. Was der Client schickt, enthält bei
 * AUTH LOGIN Benutzer und Passwort in Base64 - das gehört in kein Protokoll.
 */
final class MailCheck
{
    /** Größer wird die Datei nicht; die ältere Hälfte wandert nach mail.log.1. */
    private const GRENZE = 262144;

    /**
     * Der Transport erst beim ersten Versand: Eine ungültige MAILER_DSN soll den Versand scheitern
     * lassen und im Protokoll stehen, nicht schon die Seite, die ihn anbietet.
     */
    public function __construct(#[Autowire(service: 'mailer.transports', lazy: true)] private TransportInterface $transport, private string $dsn, private string $logFile)
    {
    }

    /**
     * Schickt die Nachricht und hält das Ergebnis fest. Wirft nie - ein kaputter Versand darf
     * keine Anfrage und keine Seite kosten.
     *
     * @return array{ok: bool, meldung: string, hinweis: string, dialog: string}
     */
    public function send(Email $email, string $anlass): array
    {
        $an = implode(', ', array_map(static fn ($adresse): string => $adresse->getAddress(), $email->getTo()));
        try {
            $gesendet = $this->transport->send($email);
            $ergebnis = [
                'ok' => true,
                'meldung' => 'Vom Mailserver angenommen.',
                'hinweis' => self::hinweisNachErfolg($this->scheme()),
                'dialog' => self::dialog((string) $gesendet?->getDebug()),
            ];
        } catch (TransportExceptionInterface $fehler) {
            $ergebnis = [
                'ok' => false,
                'meldung' => self::einzeilig($fehler->getMessage()),
                'hinweis' => self::hinweis($fehler->getMessage(), $this->scheme()),
                'dialog' => self::dialog($fehler->getDebug()),
            ];
        } catch (\Throwable $fehler) {
            // Eine ungültige MAILER_DSN fällt erst hier auf, nicht beim Start.
            $ergebnis = [
                'ok' => false,
                'meldung' => self::einzeilig($fehler->getMessage()),
                'hinweis' => self::hinweis($fehler->getMessage(), $this->scheme()),
                'dialog' => '',
            ];
        }
        $this->protokollieren(['zeit' => gmdate('Y-m-d H:i:s'), 'anlass' => $anlass, 'an' => $an, 'von' => $email->getFrom()[0]?->getAddress() ?? ''] + $ergebnis);

        return $ergebnis;
    }

    /**
     * Wie versendet wird - ohne Passwort.
     *
     * @return array{art: string, ziel: string, benutzer: string, gueltig: bool}
     */
    public function route(): array
    {
        try {
            $dsn = Dsn::fromString($this->dsn);
        } catch (\Throwable) {
            return ['art' => 'ungültig', 'ziel' => '', 'benutzer' => '', 'gueltig' => false];
        }
        $art = match ($dsn->getScheme()) {
            'smtp', 'smtps' => 'SMTP',
            'sendmail', 'sendmail+smtp' => 'sendmail des Servers',
            'native' => 'PHP mail() des Servers',
            'null' => 'kein Versand (null)',
            default => $dsn->getScheme(),
        };
        $port = $dsn->getPort();

        return [
            'art' => $art,
            'ziel' => in_array($dsn->getScheme(), ['smtp', 'smtps'], true) ? $dsn->getHost().(null !== $port ? ':'.$port : '') : '',
            'benutzer' => (string) $dsn->getUser(),
            'gueltig' => true,
        ];
    }

    /**
     * Die letzten Einträge, neueste zuerst.
     *
     * @return list<array<string, mixed>>
     */
    public function recent(int $anzahl = 10): array
    {
        if (!is_file($this->logFile)) {
            return [];
        }
        $zeilen = file($this->logFile, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES) ?: [];
        $eintraege = [];
        foreach (array_reverse(array_slice($zeilen, -$anzahl)) as $zeile) {
            $eintrag = json_decode($zeile, true);
            if (is_array($eintrag)) {
                $eintraege[] = $eintrag;
            }
        }

        return $eintraege;
    }

    public function logFile(): string
    {
        return $this->logFile;
    }

    /** Was als Nächstes zu tun ist, für die häufigen Fälle. Leer, wenn nichts passt. */
    public static function hinweis(string $meldung, string $scheme): string
    {
        $m = strtolower($meldung);

        return match (true) {
            'null' === $scheme => 'MAILER_DSN steht auf null://null - es wird gar nichts verschickt.',
            (str_contains($m, 'dsn') && (str_contains($m, 'invalid') || str_contains($m, 'malformed') || str_contains($m, 'must contain'))) || (str_contains($m, 'scheme') && str_contains($m, 'not supported')) => 'MAILER_DSN in .env ist ungültig. Form: smtp://benutzer:passwort@server:587 - @ und Sonderzeichen in Benutzer und Passwort URL-kodiert (@ → %40, # → %23, / → %2F, % → %25).',
            str_contains($m, '535') || str_contains($m, 'authenticat') => 'Der Mailserver lehnt die Anmeldung ab. Benutzer (die volle Adresse) und Passwort prüfen; Sonderzeichen im Passwort URL-kodieren (# → %23, / → %2F, % → %25, @ → %40). Bei Microsoft 365 muss für das Postfach „Authentifiziertes SMTP“ eingeschaltet sein.',
            str_contains($m, 'connection could not be established') || str_contains($m, 'connection refused') || str_contains($m, 'timed out') || str_contains($m, 'getaddrinfo') || str_contains($m, 'unable to connect') => 'Der Mailserver ist von hier aus nicht erreichbar. Servername und Port prüfen (meist 587); manche Hoster sperren ausgehende Verbindungen auf bestimmten Ports.',
            str_contains($m, 'certificate') || str_contains($m, 'ssl') || str_contains($m, 'tls') => 'Die verschlüsselte Verbindung kam nicht zustande. Port 587 nutzt STARTTLS, Port 465 braucht smtps:// - Port und Schema müssen zusammenpassen, und der Servername muss zum Zertifikat passen.',
            str_contains($scheme, 'sendmail') => 'sendmail ist auf diesem Server so nicht nutzbar. Besser über SMTP mit einem echten Postfach versenden: MAILER_DSN=smtp://benutzer:passwort@server:587 in .env.',
            1 === preg_match('/\b55[0-4]\b/', $m) || str_contains($m, 'sender') || str_contains($m, 'relay') => 'Der Mailserver nimmt Absender oder Empfänger nicht an. Der Absender muss meist genau das Postfach sein, mit dem angemeldet wird.',
            default => '',
        };
    }

    /** Angenommen heißt nicht angekommen - die üblichen Gründe dafür. */
    public static function hinweisNachErfolg(string $scheme): string
    {
        if ('null' === $scheme) {
            return self::hinweis('', 'null');
        }

        return 'Kommt nichts an: Spam-Ordner prüfen. Der Absender sollte zur eigenen Domain gehören (SPF). Liegt das Postfach des Empfängers nicht beim Hoster (etwa Microsoft 365), darf die Domain dort nicht auch als Mail-Domain eingerichtet sein - sonst stellt der Hoster intern zu.';
    }

    /**
     * Nur die Antworten des Servers aus dem SMTP-Gespräch, höchstens die letzten zwölf.
     * Symfony schreibt sie mit „< “ am Anfang, die eigenen Zeilen mit „> “.
     */
    public static function dialog(string $debug): string
    {
        $zeilen = [];
        foreach (preg_split('/\R/', $debug) ?: [] as $zeile) {
            if (str_starts_with($zeile, '< ')) {
                $zeilen[] = $zeile;
            }
        }

        return implode("\n", array_slice($zeilen, -12));
    }

    private function scheme(): string
    {
        try {
            return Dsn::fromString($this->dsn)->getScheme();
        } catch (\Throwable) {
            return '';
        }
    }

    private static function einzeilig(string $text): string
    {
        return mb_substr(trim((string) preg_replace('/\s+/', ' ', $text)), 0, 1000);
    }

    private function protokollieren(array $eintrag): void
    {
        $ordner = dirname($this->logFile);
        if (!is_dir($ordner)) {
            @mkdir($ordner, 0o775, true);
        }
        if (is_file($this->logFile) && filesize($this->logFile) > self::GRENZE) {
            @rename($this->logFile, $this->logFile.'.1');
        }
        @file_put_contents($this->logFile, json_encode($eintrag, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_INVALID_UTF8_SUBSTITUTE)."\n", FILE_APPEND | LOCK_EX);
    }
}