<?php

namespace App\Livewire\Settings;

use App\Jobs\CreateBackupArchive;
use App\Jobs\ResetApplication;
use App\Services\BackupOperationState;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\RateLimiter;
use Livewire\Component;

/**
 * Avvio e monitoraggio delle operazioni lunghe: backup, ripristino,
 * azzeramento.
 *
 * Il lavoro vero sta nei job; qui si avvia e si interroga lo stato. La barra
 * mostra `processed/total` dell'operazione in corso, cioe' unita' di lavoro
 * davvero completate — file finiti nell'archivio, file estratti, tabelle
 * svuotate — non un'animazione a tempo.
 */
class BackupManager extends Component
{
    /** Operazione seguita in questo momento; null quando non c'e' nulla in corso. */
    public ?string $operationId = null;

    public array $operazione = [];

    /** Frase da digitare per sbloccare l'azzeramento. */
    public const CONFERMA_AZZERAMENTO = 'AZZERA TUTTO';

    /** Password sbagliate ammesse prima di bloccare l'azzeramento, e per quanto. */
    private const TENTATIVI_PASSWORD = 5;
    private const FINESTRA_TENTATIVI = 300;

    public string $confermaReset = '';

    /**
     * Esiste solo per dare un nome agli errori del campo password: Livewire
     * scarta dal messaggio di risposta ogni errore la cui chiave non
     * corrisponda a una proprieta' del componente (SupportValidation::dehydrate),
     * quindi senza questa riga "Password non corretta" non arriverebbe mai a
     * schermo e il pulsante sembrerebbe non fare nulla.
     *
     * NON collegarla al campo con wire:model: la password viaggia come
     * parametro di confermaAzzeramento() proprio per non finire nello
     * snapshot, che Livewire rimanda al browser a ogni risposta. Qui resta
     * sempre stringa vuota.
     */
    public string $passwordConferma = '';

    /** Messaggio mostrato in cima quando un avvio viene rifiutato. */
    public string $erroreOperazione = '';

    public function mount(): void
    {
        $this->authorize('settings.manage');

        // Riaggancia un'operazione gia' in corso. Senza, ricaricare la pagina
        // durante un backup lungo farebbe sparire la barra, e un azzeramento
        // fermo in attesa di conferma diventerebbe irraggiungibile: nessuno
        // potrebbe piu' ne' confermarlo ne' annullarlo.
        $this->operationId = app(BackupOperationState::class)->corrente();
        $this->aggiorna();
    }

    public function avviaBackup(): void
    {
        $this->authorize('settings.manage');

        if (! $this->postoLibero()) {
            return;
        }

        $this->operationId = $this->nuovaOperazione(BackupOperationState::TIPO_BACKUP);

        CreateBackupArchive::dispatch($this->operationId, false);

        $this->aggiorna();
    }

    /**
     * Vero se non c'e' gia' un'operazione in corso.
     *
     * Backup, ripristino e azzeramento lavorano tutti sullo stesso database e
     * sullo stesso disco: farne partire due insieme — due schede, due
     * amministratori — non li rallenta soltanto, li fa sovrascrivere a vicenda.
     */
    private function postoLibero(): bool
    {
        $inCorso = app(BackupOperationState::class)->corrente();

        if ($inCorso === null) {
            $this->erroreOperazione = '';

            return true;
        }

        // Si aggancia a quella in corso invece di limitarsi a rifiutare: chi ha
        // premuto il pulsante vuole comunque vedere a che punto e'.
        $this->operationId = $inCorso;
        $this->aggiorna();
        $this->erroreOperazione = 'C\'e\' gia\' un\'operazione in corso: attendi che finisca prima di avviarne un\'altra.';

        return false;
    }

    /**
     * Primo tempo dell'azzeramento: si costruisce il backup e lo si scarica.
     * La cancellazione non parte da qui — serve il secondo tempo,
     * confermaAzzeramento(), a valle del download.
     */
    public function avviaAzzeramento(): void
    {
        $this->authorize('settings.manage');

        $this->validate(
            ['confermaReset' => 'required|in:' . self::CONFERMA_AZZERAMENTO],
            ['confermaReset.in' => 'Scrivi esattamente "' . self::CONFERMA_AZZERAMENTO . '" per confermare.',
             'confermaReset.required' => 'Scrivi "' . self::CONFERMA_AZZERAMENTO . '" per confermare.']
        );

        if (! $this->postoLibero()) {
            return;
        }

        $this->confermaReset = '';
        $this->operationId = $this->nuovaOperazione(BackupOperationState::TIPO_RESET);

        CreateBackupArchive::dispatch($this->operationId, true);

        $this->aggiorna();
    }

    /**
     * Secondo tempo dell'azzeramento: parte solo su conferma esplicita, dopo
     * che l'archivio e' stato servito.
     *
     * La conferma umana non e' un doppione del `wire:confirm` iniziale: e' il
     * solo punto in cui si sa che il backup e' davvero sul computer di chi sta
     * cancellando. Il server puo' verificare di averlo *spedito*
     * (`servito_at`), non che sia arrivato: nginx bufferizza la risposta, il
     * processo PHP la considera scritta e un download annullato dal browser
     * resterebbe indistinguibile da uno riuscito. Chiedere all'operatore e'
     * l'unico controllo che copre anche quel caso.
     */
    public function confermaAzzeramento(string $password = ''): void
    {
        $this->authorize('settings.manage');

        $this->aggiorna();

        if (($this->operazione['fase'] ?? null) !== BackupOperationState::FASE_ATTESA_DOWNLOAD) {
            $this->addError('confermaReset', 'Nessun azzeramento in attesa di conferma.');

            return;
        }

        if (($this->operazione['result']['servito_at'] ?? null) === null) {
            $this->addError('confermaReset', 'Scarica prima il backup: senza, l\'azzeramento non parte.');

            return;
        }

        if (! $this->passwordConfermata($password)) {
            return;
        }

        app(BackupOperationState::class)->update($this->operationId, function (array $state) {
            $state['fase'] = 'Azzeramento in avvio';
            $state['processed'] = 0;
            $state['total'] = 0;

            return $state;
        });

        ResetApplication::dispatch($this->operationId, (int) auth()->id());

        $this->aggiorna();
    }

    /**
     * Verifica la password dell'amministratore prima della cancellazione.
     *
     * A questo punto la sessione e' gia' autenticata, quindi la password non
     * serve a stabilire *chi* sia: serve a stabilire che davanti allo schermo
     * ci sia ancora quella persona. E' l'ultimo passo prima di
     * un'operazione irreversibile, e una scheda lasciata aperta su una
     * postazione condivisa e' lo scenario esatto contro cui protegge.
     *
     * La password arriva come parametro del metodo e non come proprieta' del
     * componente: le proprieta' pubbliche di Livewire vengono serializzate
     * nello snapshot e rispedite al browser a ogni risposta, e una password
     * non ha motivo di fare quel viaggio di ritorno.
     */
    private function passwordConfermata(string $password): bool
    {
        $utente = auth()->user();
        $chiave = 'azzeramento-password:' . $utente->id;

        // Senza un limite, la richiesta di password su una sessione dirottata
        // sarebbe solo un rallentamento: si proverebbero le password comuni a
        // raffica. Il blocco e' sull'azione, non sull'account, quindi nessuno
        // resta chiuso fuori dall'applicazione.
        if (RateLimiter::tooManyAttempts($chiave, self::TENTATIVI_PASSWORD)) {
            $this->addError('passwordConferma', sprintf(
                'Troppi tentativi. Riprova fra %d secondi.',
                RateLimiter::availableIn($chiave)
            ));

            return false;
        }

        if ($password === '') {
            $this->addError('passwordConferma', 'Inserisci la tua password per confermare.');

            return false;
        }

        if (! Hash::check($password, $utente->getAuthPassword())) {
            RateLimiter::hit($chiave, self::FINESTRA_TENTATIVI);
            $this->addError('passwordConferma', 'Password non corretta.');

            return false;
        }

        RateLimiter::clear($chiave);

        return true;
    }

    /**
     * Annulla un azzeramento fermo in attesa di conferma. Il backup resta
     * scaricabile: e' comunque un backup valido.
     */
    public function annullaAzzeramento(): void
    {
        $this->authorize('settings.manage');

        if (($this->operazione['fase'] ?? null) !== BackupOperationState::FASE_ATTESA_DOWNLOAD) {
            return;
        }

        app(BackupOperationState::class)->markCompleted($this->operationId, [
            'messaggio' => 'Azzeramento annullato. Il backup appena creato resta scaricabile.',
        ]);

        // Da qui in poi e' un backup come un altro: la scheda mostra il
        // pulsante di download, non piu' la conferma di cancellazione.
        app(BackupOperationState::class)->update($this->operationId, function (array $state) {
            $state['tipo'] = BackupOperationState::TIPO_BACKUP;

            return $state;
        });

        $this->aggiorna();
    }

    /**
     * Aggancia un'operazione avviata fuori da Livewire (il ripristino, che
     * parte da un upload XHR e restituisce il suo id in JSON).
     */
    public function seguiOperazione(string $operationId): void
    {
        $this->authorize('settings.manage');

        $this->operationId = $operationId;
        $this->aggiorna();
    }

    public function aggiorna(): void
    {
        if (! $this->operationId) {
            return;
        }

        $stato = app(BackupOperationState::class)->get($this->operationId);

        if (! $stato) {
            $this->operationId = null;
            $this->operazione = [];

            return;
        }

        $this->operazione = $stato;

        // Il download parte da solo appena l'archivio e' pronto: per il backup
        // e' una comodita', per l'azzeramento e' il passaggio che sblocca la
        // cancellazione, quindi non puo' dipendere da un clic.
        if ($this->scaricaOra()) {
            $this->dispatch('scarica-backup', url: route('backup.file', $this->operationId));
        }
    }

    public function chiudi(): void
    {
        $this->operationId = null;
        $this->operazione = [];
    }

    /**
     * True una volta sola per operazione: l'evento di download va emesso quando
     * l'archivio compare, non a ogni poll successivo.
     */
    private function scaricaOra(): bool
    {
        $pronto = ($this->operazione['result']['file'] ?? null) !== null;
        $giaInviato = $this->operazione['result']['download_inviato'] ?? false;

        if (! $pronto || $giaInviato) {
            return false;
        }

        app(BackupOperationState::class)->update($this->operationId, function (array $state) {
            $state['result']['download_inviato'] = true;

            return $state;
        });

        $this->operazione['result']['download_inviato'] = true;

        return true;
    }

    private function nuovaOperazione(string $tipo): string
    {
        $operationId = (string) \Illuminate\Support\Str::uuid();

        $stato = app(BackupOperationState::class);
        $stato->initialize($operationId, $tipo, 'In coda');
        $stato->log($operationId, 'Operazione creata. In attesa del worker di coda.');

        return $operationId;
    }

    /** Percentuale della fase corrente, 0-100. */
    public function getPercentualeProperty(): int
    {
        $stato = $this->operazione['status'] ?? null;

        if ($stato === 'completed') {
            return 100;
        }

        $total = (int) ($this->operazione['total'] ?? 0);

        if ($total <= 0) {
            return 0;
        }

        $processed = (int) ($this->operazione['processed'] ?? 0);

        return (int) min(100, round($processed / $total * 100));
    }

    /** Se true la pagina continua a interrogare lo stato. */
    public function getInCorsoProperty(): bool
    {
        return $this->operationId !== null
            && in_array($this->operazione['status'] ?? '', ['queued', 'running'], true);
    }

    /**
     * Ogni quanto reinterrogare lo stato.
     *
     * Mentre un job lavora servono aggiornamenti fitti, la barra deve muoversi.
     * In attesa-download invece si aspetta una persona, che puo' metterci
     * minuti: continuare a bussare ogni 750ms vorrebbe dire migliaia di
     * richieste inutili se qualcuno lascia la scheda aperta e se ne va.
     */
    public function getIntervalloPollProperty(): string
    {
        return ($this->operazione['fase'] ?? null) === BackupOperationState::FASE_ATTESA_DOWNLOAD
            ? '5s'
            : '750ms';
    }

    public function render()
    {
        return view('livewire.settings.backup-manager');
    }
}