<?php

namespace App\EventPaymentModules;

use App\Enumerations\PaymentStatus;
use App\EventPaymentModules\DTO\CreateInvoiceRequest;
use App\EventPaymentModules\DTO\CreateInvoiceResponse;
use App\EventPaymentModules\DTO\DoPaymentRequest;
use App\EventPaymentModules\DTO\DoPaymentResponse;
use App\EventPaymentModules\DTO\RegistrationSummaryRequest;
use App\EventPaymentModules\DTO\RegistrationSummaryResponse;

/**
 * Gemeinsame Basis aller Zahlungsmodule. Hält den geteilten Code und die aus {@see getOptions()}
 * abgeleiteten Options-Helfer; konkrete Module definieren nur ihre Identität, ihr Options-Schema
 * und -- später -- die je Zahlungsart variierenden Teile (z.B. den Rechnungs-Schlusssatz).
 */
abstract class AbstractEventPaymentModule implements EventPaymentModule
{
    public function defaultDescription(): ?string
    {
        return null;
    }

    /**
     * Standard-Konfiguration beim Anlegen der Tenant-Instanz. Standard: leer.
     *
     * @return array<string, mixed>
     */
    public function defaultConfiguration(): array
    {
        return [];
    }

    /**
     * Payer-seitige Eingaben, die eine Zahlungsart vom Teilnehmer benötigt (z.B. später SEPA-IBAN,
     * PayPal-Mail). Standard: keine. Gleiche Form wie getOptions(): [{name,label,type,required}].
     *
     * @return array<int, array{name: string, label: string, type: string, required: bool}>
     */
    public function getParticipantOptions(): array
    {
        return [];
    }

    // -----------------------------------------------------------------------------------------
    // Aus dem jeweiligen Schema abgeleitete Helfer (Admin-Config = getOptions(),
    // Teilnehmer-Eingaben = getParticipantOptions()).
    // -----------------------------------------------------------------------------------------

    /** @return array<int, string> */
    public function requiredOptionKeys(): array
    {
        return $this->requiredKeys($this->getOptions());
    }

    /**
     * @param array<string, mixed> $config
     * @return array<string, mixed>
     */
    public function sanitizeConfiguration(array $config): array
    {
        return $this->sanitizeAgainst($this->getOptions(), $config);
    }

    /** @param array<string, mixed> $config */
    public function isConfigurationComplete(array $config): bool
    {
        return $this->allRequiredFilled($this->getOptions(), $config);
    }

    /**
     * Optionen mit `scope => 'tenant'`: Sie gelten für den ganzen Mandanten und werden **nicht** pro
     * Veranstaltung eingefroren.
     *
     * Beispiel ist das Kontoauszug-Format: Es beschreibt die Bank, nicht die Zusage an die
     * Teilnehmenden. Läge es im Event-Snapshot, ließe sich nach einem Bankwechsel für laufende
     * Aktionen nichts mehr importieren, bis das Format bei jeder einzeln nachgezogen wurde.
     * IBAN und Kontoinhaber bleiben dagegen weiterhin pro Aktion eingefroren.
     *
     * @return array<int, string>
     */
    public function tenantScopedOptionKeys(): array
    {
        return array_values(array_map(
            static fn (array $option) => $option['name'],
            array_filter($this->getOptions(), static fn (array $option) => ($option['scope'] ?? null) === 'tenant')
        ));
    }

    /**
     * Entfernt die tenant-weiten Optionen aus einer Konfiguration -- angewandt auf den
     * Copy-on-Assign-Snapshot einer Veranstaltung.
     *
     * @param array<string, mixed> $config
     * @return array<string, mixed>
     */
    public function stripTenantScopedOptions(array $config): array
    {
        return array_diff_key($config, array_flip($this->tenantScopedOptionKeys()));
    }

    /**
     * @param array<string, mixed> $input
     * @return array<string, mixed>
     */
    public function sanitizeParticipantOptions(array $input): array
    {
        return $this->sanitizeAgainst($this->getParticipantOptions(), $input);
    }

    /** @param array<string, mixed> $input */
    public function participantOptionsComplete(array $input): bool
    {
        return $this->allRequiredFilled($this->getParticipantOptions(), $input);
    }

    /**
     * Die Teilnehmer-Optionen, die im Anmeldeformular tatsächlich abgefragt werden.
     *
     * Optionen mit `system => true` fallen heraus: Sie liegen zwar in `payment_options`, entstehen aber
     * im Programm statt durch eine Eingabe -- das Zahler-Konto etwa trägt der Import aus dem
     * Kontoauszug nach. Im Schema müssen sie trotzdem stehen, sonst verwirft
     * {@see sanitizeParticipantOptions()} sie als unbekannte Schlüssel.
     *
     * @return array<int, array{name: string, label: string, type: string, required: bool}>
     */
    public function participantInputOptions(): array
    {
        return array_values(array_filter(
            $this->getParticipantOptions(),
            static fn (array $option): bool => ($option['system'] ?? false) !== true,
        ));
    }

    /**
     * @param array<int, array{name: string, required?: bool}> $schema
     * @return array<int, string>
     */
    private function requiredKeys(array $schema): array
    {
        return array_values(array_map(
            static fn (array $option) => $option['name'],
            array_filter($schema, static fn(array $option) => $option['required'] ?? false)
        ));
    }

    /**
     * Reduziert Eingaben auf die im Schema definierten Keys (unbekannte werden verworfen).
     *
     * @param array<int, array{name: string}> $schema
     * @param array<string, mixed> $input
     * @return array<string, mixed>
     */
    private function sanitizeAgainst(array $schema, array $input): array
    {
        $result = [];
        foreach ($schema as $option) {
            if (array_key_exists($option['name'], $input)) {
                $result[$option['name']] = $input[$option['name']];
            }
        }

        return $result;
    }

    /**
     * Sind alle Pflichtfelder des Schemas befüllt (non-empty)?
     *
     * @param array<int, array{name: string, required?: bool}> $schema
     * @param array<string, mixed> $input
     */
    private function allRequiredFilled(array $schema, array $input): bool
    {
        foreach ($this->requiredKeys($schema) as $key) {
            $value = $input[$key] ?? null;
            if ($value === null || $value === '' || $value === []) {
                return false;
            }
        }

        return true;
    }

    // -----------------------------------------------------------------------------------------
    // Operative Methoden -- in dieser Iteration bewusst als Stubs.
    // -----------------------------------------------------------------------------------------

    public function registrationSummary(RegistrationSummaryRequest $request): RegistrationSummaryResponse
    {
        // TODO: In einer Folge-Iteration ausformulieren (zahlungsspezifischer Teil der Zusammenfassung).
        return new RegistrationSummaryResponse();
    }

    public function doPayment(DoPaymentRequest $request): DoPaymentResponse
    {
        // TODO: In einer Folge-Iteration ausformulieren. Default: nichts aktiv anzustoßen (Status offen).
        $response = new DoPaymentResponse();
        $response->success = true;
        $response->status = PaymentStatus::PAYMENT_STATUS_PENDING;

        return $response;
    }

    /**
     * Template-Method: Der gemeinsame Rechnungs-Rumpf wird hier gebaut, der variierende Schlusssatz
     * kommt aus {@see invoiceClosingStatement()} des jeweiligen Moduls.
     *
     * `$request->amount` ist der noch offene Betrag. Ist nichts mehr offen, gilt unabhängig von der
     * Zahlungsart derselbe Satz -- eine Zahlungsaufforderung wäre dann schlicht falsch.
     */
    public function createInvoice(CreateInvoiceRequest $request): CreateInvoiceResponse
    {
        $response = new CreateInvoiceResponse();
        $response->success = true;

        $response->closingStatement = $request->amount->getAmount() <= 0
            ? 'Der Betrag ist bereits vollständig beglichen — vielen Dank.'
            : $this->invoiceClosingStatement($request);

        return $response;
    }

    /**
     * Der je Zahlungsart variierende Schlusssatz der Rechnung
     * ("Bitte überweise bis ..." / "wird abgebucht ..." / "wurde per PayPal beglichen").
     *
     * Wird nur bei tatsächlich offenem Betrag aufgerufen.
     */
    abstract protected function invoiceClosingStatement(CreateInvoiceRequest $request): string;
}