<?php
namespace App\Filament\Pages\Strumenti;

use App\Models\Documento;
use App\Models\DocumentoArchivioCartella;
use App\Models\DocumentoArchivioFisicoItem;
use App\Models\MovimentoContabile;
use App\Models\Stabile;
use App\Models\User;
use App\Services\Documenti\DocumentoArchivioVisibilityService;
use App\Services\Documenti\PdfTextExtractionService;
use App\Support\StabileContext;
use BackedEnum;
use Carbon\Carbon;
use Dompdf\Dompdf;
use Filament\Actions\Action;
use Filament\Forms\Components\DatePicker;
use Filament\Forms\Components\FileUpload;
use Filament\Forms\Components\Select;
use Filament\Forms\Components\Textarea;
use Filament\Forms\Components\TextInput;
use Filament\Forms\Components\Toggle;
use Filament\Notifications\Notification;
use Filament\Pages\Page;
use Filament\Tables\Columns\BadgeColumn;
use Filament\Tables\Columns\IconColumn;
use Filament\Tables\Columns\TextColumn;
use Filament\Tables\Concerns\InteractsWithTable;
use Filament\Tables\Contracts\HasTable;
use Filament\Tables\Filters\SelectFilter;
use Filament\Tables\Table;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Str;
use Livewire\Attributes\Url;
use UnitEnum;

class DocumentiArchivio extends Page implements HasTable
{
    use InteractsWithTable;

    #[Url( as : 'tab')]
    public string $hubTab = 'protocollo-comunicazioni';

    public string $protocolloSearch = '';

    public string $protocolloCategory = '';

    public string $protocolloView = 'cards';

    #[Url( as : 'folder')]
    public ?int $currentFolderId = null;

    public array $physicalArchiveForm = [];

    public array $physicalArchiveMoveForm = [];

    public string $physicalArchiveSearch = '';

    public string $physicalArchiveTypeFilter = '';

    protected static ?string $navigationLabel = 'Documenti (PDF)';

    protected static ?string $title = 'Documenti (PDF)';

    protected static BackedEnum|string|null $navigationIcon = 'heroicon-o-document-text';

    protected static UnitEnum|string|null $navigationGroup = 'Strumenti';

    protected static ?int $navigationSort = 61;

    protected static ?string $slug = 'strumenti/documenti';

    protected string $view = 'filament.pages.strumenti.documenti-archivio';

    private ?DocumentoArchivioVisibilityService $visibilityService = null;

    public static function canAccess(): bool
    {
        $user = Auth::user();
        return $user instanceof User
        && $user->hasAnyRole(['super-admin', 'admin', 'amministratore', 'collaboratore']);
    }

    public function mount(): void
    {
        $this->hubTab = $this->normalizeHubTab($this->hubTab);
        $this->syncInvoiceFolders();
        $this->initializePhysicalArchiveForms();
        $this->mountInteractsWithTable();
    }

    public function selectHubTab(string $tab): void
    {
        $this->hubTab = $this->normalizeHubTab($tab);

        if ($this->hubTab === 'archivio-digitale') {
            $this->syncInvoiceFolders();
        }
    }

    public function setProtocolloView(string $view): void
    {
        $this->protocolloView = in_array($view, ['cards', 'list'], true) ? $view : 'cards';
    }

    protected function getHeaderActions(): array
    {
        return [
            Action::make('registra_documento')
                ->label('Registra documento (PDF)')
                ->icon('heroicon-o-plus')
                ->form($this->getDocumentoFormSchema())
                ->action(function (array $data): void {
                    $this->createDocumentoFromForm($data, false);
                }),

            Action::make('crea_demo_contratto_ascensori')
                ->label('Crea demo: Contratto Ascensori')
                ->icon('heroicon-o-sparkles')
                ->form([
                    Select::make('stabile_id')
                        ->label('Stabile')
                        ->options(fn() => $this->getStabiliOptions())
                        ->default(fn() => $this->getDefaultStabileId())
                        ->searchable()
                        ->required(),
                    TextInput::make('faldone')
                        ->label('Faldone (opzionale)')
                        ->placeholder('Es. CONTR-2024')
                        ->maxLength(50),
                ])
                ->action(function (array $data): void {
                    $this->createDocumentoDemoContrattoAscensori((int) $data['stabile_id'], (string) ($data['faldone'] ?? ''));
                }),

            Action::make('nuova_cartella_archivio')
                ->label('Nuova cartella archivio')
                ->icon('heroicon-o-folder-plus')
                ->color('gray')
                ->form($this->getArchivioFolderFormSchema())
                ->action(function (array $data): void {
                    $this->createArchivioFolder($data);
                }),
        ];
    }

    protected function getTableQuery(): Builder
    {
        $user = Auth::user();
        if (! $user instanceof User) {
            return Documento::query()->whereRaw('1 = 0');
        }

        $query = $this->getVisibilityService()
            ->scopeVisibleDocumenti(Documento::query()->with('cartellaArchivio'), $user);

        if ($this->hubTab === 'archivio-digitale') {
            $stabileId = (int) ($this->resolveActiveStabile()?->id ?? 0);
            if ($stabileId > 0) {
                $query->where('stabile_id', $stabileId)
                    ->where('tipo_documento', 'fattura');

                if ($this->currentFolderId) {
                    $query->where('cartella_archivio_id', $this->currentFolderId);
                } else {
                    $query->whereRaw('1 = 0');
                }
            }
        }

        return $query;
    }

    public function table(Table $table): Table
    {
        return $table
            ->striped()
            ->defaultSort('created_at', 'desc')
            ->columns([
                TextColumn::make('numero_protocollo')
                    ->label('Protocollo')
                    ->copyable()
                    ->searchable(),
                TextColumn::make('nome_file')
                    ->label('Nome archivio')
                    ->state(fn(Documento $record): string => trim((string) ($record->nome_file ?: $record->nome ?: '—')))
                    ->searchable()
                    ->limit(65)
                    ->wrap(),
                BadgeColumn::make('tipo_documento')
                    ->label('Categoria')
                    ->toggleable()
                    ->formatStateUsing(fn($state, Documento $record) => $state ?: ($record->tipologia ?: '—')),
                TextColumn::make('archive_reference')
                    ->label('Percorso archivio')
                    ->limit(55)
                    ->wrap()
                    ->toggleable(),
                TextColumn::make('descrizione')
                    ->label('Descrizione')
                    ->limit(50)
                    ->toggleable(isToggledHiddenByDefault: true)
                    ->searchable(),
                TextColumn::make('fornitore')
                    ->label('Fornitore/Ente')
                    ->searchable()
                    ->limit(35)
                    ->toggleable(),
                TextColumn::make('cartellaArchivio.nome')
                    ->label('Cartella')
                    ->toggleable()
                    ->wrap(),
                TextColumn::make('metadati_archivio.classe')
                    ->label('Classe archivio')
                    ->state(fn(Documento $record): string => (string) data_get($record->metadati_archivio ?? [], 'classe_label', '—'))
                    ->toggleable(),
                TextColumn::make('metadati_archivio.supporto_fisico')
                    ->label('Supporto')
                    ->state(fn(Documento $record): string => (string) data_get($record->metadati_archivio ?? [], 'supporto_fisico', '—'))
                    ->toggleable(isToggledHiddenByDefault: true),
                TextColumn::make('metadati_archivio.posizione_fisica')
                    ->label('Posizione fisica')
                    ->state(fn(Documento $record): string => $this->formatPhysicalArchiveLocation($record))
                    ->toggleable(),
                TextColumn::make('contenuto_ocr')
                    ->label('Testo (OCR)')
                    ->limit(50)
                    ->toggleable(isToggledHiddenByDefault: true)
                    ->searchable(),
                TextColumn::make('data_documento')
                    ->label('Data')
                    ->date('d-m-Y')
                    ->toggleable(),
                TextColumn::make('data_scadenza')
                    ->label('Scadenza')
                    ->date('d-m-Y')
                    ->toggleable(),
                TextColumn::make('importo_collegato')
                    ->label('Importo')
                    ->money('EUR')
                    ->toggleable(),
                IconColumn::make('archiviato')
                    ->label('Arch.')
                    ->boolean()
                    ->toggleable(),
            ])
            ->filters([
                SelectFilter::make('tipo_documento')
                    ->label('Categoria')
                    ->options($this->getCategorieOptions()),
            ])
            ->actions([
                Action::make('visualizza_pdf')
                    ->hiddenLabel()
                    ->icon('heroicon-o-eye')
                    ->tooltip('Visualizza PDF')
                    ->visible(fn(Documento $record) => $this->hasPdf($record))
                    ->modalHeading(fn(Documento $record): string => trim((string) ($record->nome ?: 'Documento PDF')))
                    ->modalWidth('7xl')
                    ->modalContent(function (Documento $record) {
                        $openUrl = route('filament.documenti.download', $record);

                        return view('filament.modals.pdf-viewer', [
                            'url'     => $openUrl . '?inline=1',
                            'openUrl' => $openUrl,
                            'title'   => trim((string) ($record->nome ?: 'Documento PDF')),
                        ]);
                    })
                    ->modalSubmitAction(false)
                    ->modalCancelActionLabel('Chiudi'),
                Action::make('scarica_pdf')
                    ->hiddenLabel()
                    ->icon('heroicon-o-arrow-down-tray')
                    ->tooltip('Scarica PDF')
                    ->url(fn(Documento $record) => route('filament.documenti.download', $record), true)
                    ->visible(fn(Documento $record) => $this->hasPdf($record)),
                Action::make('stampa_pdf')
                    ->hiddenLabel()
                    ->icon('heroicon-o-printer')
                    ->tooltip('Apri per stampa')
                    ->url(fn(Documento $record) => route('filament.documenti.download', $record) . '?inline=1', true)
                    ->visible(fn(Documento $record) => $this->hasPdf($record)),
                Action::make('stampa_pdf_watermark')
                    ->hiddenLabel()
                    ->icon('heroicon-o-document-duplicate')
                    ->tooltip('Apri con watermark archivio')
                    ->url(fn(Documento $record) => route('filament.documenti.download', $record) . '?inline=1&watermark=1', true)
                    ->visible(fn(Documento $record) => $this->hasPdf($record)),
                Action::make('archivia_fisico')
                    ->hiddenLabel()
                    ->icon('heroicon-o-archive-box')
                    ->tooltip('Collega archivio fisico')
                    ->fillForm(fn(Documento $record): array=> [
                        'supporto_fisico'        => data_get($record->metadati_archivio ?? [], 'supporto_fisico'),
                        'modello_etichetta'      => data_get($record->metadati_archivio ?? [], 'modello_etichetta', '11354'),
                        'busta_numero'           => data_get($record->metadati_archivio ?? [], 'busta_numero'),
                        'fascicolo_numero'       => data_get($record->metadati_archivio ?? [], 'fascicolo_numero'),
                        'contenitore_numero'     => data_get($record->metadati_archivio ?? [], 'contenitore_numero'),
                        'periodo_riferimento_da' => data_get($record->metadati_archivio ?? [], 'periodo_da'),
                        'periodo_riferimento_a'  => data_get($record->metadati_archivio ?? [], 'periodo_a'),
                        'watermark_predefinito'  => (bool) data_get($record->metadati_archivio ?? [], 'watermark_predefinito', false),
                    ])
                    ->form([
                        Select::make('supporto_fisico')
                            ->label('Supporto fisico')
                            ->options(array_combine($this->archivioFisicoTypes, $this->archivioFisicoTypes))
                            ->searchable(),
                        Select::make('modello_etichetta')
                            ->label('Modello etichetta')
                            ->options($this->getModelliEtichettaOptions())
                            ->default('11354')
                            ->native(false),
                        TextInput::make('contenitore_numero')
                            ->label('Contenitore / faldone'),
                        TextInput::make('busta_numero')
                            ->label('Busta n.'),
                        TextInput::make('fascicolo_numero')
                            ->label('Fascicolo n.'),
                        DatePicker::make('periodo_riferimento_da')
                            ->label('Periodo dal'),
                        DatePicker::make('periodo_riferimento_a')
                            ->label('Periodo al'),
                        Toggle::make('watermark_predefinito')
                            ->label('Watermark predefinito in stampa')
                            ->default(false),
                    ])
                    ->action(function (Documento $record, array $data): void {
                        $meta                          = is_array($record->metadati_archivio ?? null) ? $record->metadati_archivio : [];
                        $meta['supporto_fisico']       = $this->normalizeNullableText($data['supporto_fisico'] ?? null);
                        $meta['modello_etichetta']     = $this->normalizeNullableText($data['modello_etichetta'] ?? null);
                        $meta['contenitore_numero']    = $this->normalizeNullableText($data['contenitore_numero'] ?? null);
                        $meta['busta_numero']          = $this->normalizeNullableText($data['busta_numero'] ?? null);
                        $meta['fascicolo_numero']      = $this->normalizeNullableText($data['fascicolo_numero'] ?? null);
                        $meta['periodo_da']            = $data['periodo_riferimento_da'] ?? null;
                        $meta['periodo_a']             = $data['periodo_riferimento_a'] ?? null;
                        $meta['watermark_predefinito'] = (bool) ($data['watermark_predefinito'] ?? false);
                        $record->metadati_archivio     = $meta;
                        $record->save();

                        Notification::make()
                            ->title('Archivio fisico aggiornato')
                            ->success()
                            ->send();
                    }),
                Action::make('etichetta_11354')
                    ->hiddenLabel()
                    ->icon('heroicon-o-tag')
                    ->tooltip('Etichetta 11354')
                    ->url(fn(Documento $record) => route('filament.documenti.etichetta', $record) . '?format=11354&dymo_fix=0&dymo_rot=0&dymo_dx=0&dymo_dy=3&autoprint=1', false),
                Action::make('etichetta_11354_driver_verticale')
                    ->hiddenLabel()
                    ->icon('heroicon-o-tag')
                    ->tooltip('Etichetta 11354 verticale')
                    ->url(fn(Documento $record) => route('filament.documenti.etichetta', $record) . '?format=11354&dymo_fix=1&dymo_rot=-90&dymo_dx=0&dymo_dy=0&autoprint=1', false),
                Action::make('etichetta_99014')
                    ->hiddenLabel()
                    ->icon('heroicon-o-tag')
                    ->tooltip('Etichetta 99014')
                    ->url(fn(Documento $record) => route('filament.documenti.etichetta', $record) . '?format=99014&autoprint=1', false),
            ]);
    }

    private function getCategorieOptions(): array
    {
        return [
            'contratto'     => 'Contratti (CONTR)',
            'assicurazione' => 'Assicurazioni (ASSIC)',
            'certificato'   => 'Certificati (CERT)',
            'planimetria'   => 'Planimetrie (PLAN)',
            'fascicolo'     => 'Fascicolo fabbricato (FASC)',
            'anagrafica'    => 'Anagrafica condominiale (ANAG)',
            'tabella'       => 'Tabelle millesimali (TABM)',
            'regolamento'   => 'Regolamento (REGO)',
            'scritture'     => 'Scritture contabili (CONT)',
            'chiavi'        => 'Chiavi stabile (CHIA)',
            'timbri'        => 'Timbri stabile (TIMB)',
            'preventivo'    => 'Preventivi (PREV)',
            'fattura'       => 'Fatture (FATT)',
            'verbale'       => 'Verbali (VERB)',
            'altro'         => 'Altri (DOC)',
        ];
    }

    public function getHubStatsProperty(): array
    {
        $query = $this->getTableQuery();

        return [
            'documenti'      => (clone $query)->count(),
            'archiviati'     => (clone $query)->where('archiviato', true)->count(),
            'in_scadenza'    => (clone $query)->whereNotNull('data_scadenza')->whereDate('data_scadenza', '<=', now()->addDays(30)->toDateString())->count(),
            'template_drive' => count($this->getDriveTemplateFoldersProperty()),
        ];
    }

    public function openDigitalFolder(?int $folderId = null): void
    {
        $this->syncInvoiceFolders();

        if ($folderId === null) {
            $this->currentFolderId = null;
            return;
        }

        $folder = DocumentoArchivioCartella::query()->find($folderId);
        if (! $folder instanceof DocumentoArchivioCartella) {
            $this->currentFolderId = null;
            return;
        }

        $stabileId = (int) ($this->resolveActiveStabile()?->id ?? 0);
        if ($stabileId > 0 && (int) $folder->stabile_id !== $stabileId) {
            return;
        }

        $this->currentFolderId = (int) $folder->id;
    }

    public function getDigitalArchiveRootLabelProperty(): string
    {
        $stabile = $this->resolveActiveStabile();

        return trim((string) ($stabile?->denominazione ?: 'Stabile attivo'));
    }

    public function getDigitalArchiveCurrentFolderProperty(): ?DocumentoArchivioCartella
    {
        if (! $this->currentFolderId) {
            return null;
        }

        return DocumentoArchivioCartella::query()->find($this->currentFolderId);
    }

    public function getDigitalArchiveCurrentFolderDocumentCountProperty(): int
    {
        $stabileId = (int) ($this->resolveActiveStabile()?->id ?? 0);
        if ($stabileId <= 0 || ! $this->currentFolderId) {
            return 0;
        }

        return (int) Documento::query()
            ->where('stabile_id', $stabileId)
            ->where('tipo_documento', 'fattura')
            ->where('cartella_archivio_id', $this->currentFolderId)
            ->count();
    }

    public function getDigitalArchiveCurrentFolderHintProperty(): string
    {
        $folder = $this->digitalArchiveCurrentFolder;
        if (! $folder instanceof DocumentoArchivioCartella) {
            return 'Seleziona la cartella annuale per vedere l’elenco dei PDF già ordinati per protocollo e data.';
        }

        return trim((string) ($folder->percorso_logico ?: $folder->nome));
    }

    public function getDigitalArchiveFoldersProperty(): array
    {
        $stabile = $this->resolveActiveStabile();
        if (! $stabile instanceof Stabile) {
            return [];
        }

        $root = $this->ensureInvoiceRootFolder((int) $stabile->id);
        if (! $root instanceof DocumentoArchivioCartella) {
            return [];
        }

        if (! $this->currentFolderId) {
            return [[
                'id'          => (int) $root->id,
                'nome'        => (string) $root->nome,
                'descrizione' => 'Cartella fatture PDF',
                'conteggio'   => (int) Documento::query()
                    ->where('stabile_id', $stabile->id)
                    ->where('tipo_documento', 'fattura')
                    ->count(),
            ]];
        }

        return DocumentoArchivioCartella::query()
            ->where('parent_id', $this->currentFolderId)
            ->where('is_active', true)
            ->orderBy('sort_order')
            ->orderBy('nome')
            ->get()
            ->map(fn(DocumentoArchivioCartella $folder): array=> [
                'id'          => (int) $folder->id,
                'nome'        => (string) $folder->nome,
                'descrizione' => (string) ($folder->percorso_logico ?: $folder->nome),
                'conteggio'   => (int) $folder->documenti()->count(),
            ])
            ->all();
    }

    public function getDigitalArchiveBreadcrumbsProperty(): array
    {
        $items = [[
            'label'     => $this->digitalArchiveRootLabel,
            'folder_id' => null,
        ]];

        $current = $this->digitalArchiveCurrentFolder;
        if (! $current instanceof DocumentoArchivioCartella) {
            return $items;
        }

        $chain = collect();
        while ($current instanceof DocumentoArchivioCartella) {
            $chain->prepend([
                'label'     => (string) $current->nome,
                'folder_id' => (int) $current->id,
            ]);
            $current = $current->parent;
        }

        return array_merge($items, $chain->all());
    }

    /** @return array<int, string> */
    public function getDriveTemplateFoldersProperty(): array
    {
        $items     = config('netgescon.google.drive_template_folders', []);
        $yearRoot  = trim((string) config('netgescon.google.drive_template_year_root', ''));
        $yearModel = trim((string) config('netgescon.google.drive_template_year_model', ''));

        $folders = is_array($items)
            ? array_values(array_filter(array_map('strval', $items), fn(string $item) : bool => trim($item) !== ''))
            : [];

        if ($yearRoot !== '' && $yearModel !== '') {
            foreach ($folders as $folder) {
                $folders[] = $yearRoot . '/' . $yearModel . '/' . $folder;
            }
        }

        return array_values(array_unique($folders));
    }

    /** @return array<int, string> */
    public function getAudienceGroupsProperty(): array
    {
        return [
            'Condomini',
            'Inquilini',
            'Fornitori',
            'Collaboratori interni',
            'Amministratore',
            'Studio completo',
        ];
    }

    /** @return array<int, string> */
    public function getArchivioFisicoTypesProperty(): array
    {
        return [
            'Busta trasparente con anelli da archiviare',
            'Cartella a tre lembi',
            'Faldone con anelli',
            'Faldone con lacci',
            'Scatola',
        ];
    }

    /** @return array<string, string> */
    public function getArchivioClasseOptions(): array
    {
        return [
            'libro_verbali'                  => 'Libro verbali',
            'planimetria_stabile'            => 'Planimetria stabile',
            'elaborato_planimetrico'         => 'Elaborato planimetrico',
            'scheda_anagrafica_condominiale' => 'Scheda anagrafica condominiale',
            'fascicolo_fabbricato'           => 'Fascicolo fabbricato',
            'polizza_fabbricato'             => 'Polizza global fabbricato',
            'certificazioni_impianti'        => 'Certificazioni e conformita impianti',
            'decreti_vincolo'                => 'Decreti di vincolo',
            'tabelle_millesimali'            => 'Tabelle millesimali',
            'regolamento_condominio'         => 'Regolamento di condominio',
            'rendiconti_approvati'           => 'Rendiconti approvati',
            'raccolta_contratti'             => 'Raccolta contratti stipulati',
            'servitu_diritti_terzi'          => 'Servitu e diritti di terzi',
            'giustificativi_spesa'           => 'Giustificativi di spesa',
            'scritture_contabili'            => 'Scritture contabili e sostituto imposta',
            'codice_fiscale'                 => 'Codice fiscale',
            'partita_iva_amministratore'     => 'Partita IVA amministratore',
            'chiavi_stabile'                 => 'Chiavi stabile',
            'timbri_stabile'                 => 'Timbri stabile',
            'altro'                          => 'Altro contenuto archivio',
        ];
    }

    /** @return array<string, string> */
    public function getModelliEtichettaOptions(): array
    {
        return [
            '11354' => 'DYMO 11354',
            '99014' => 'DYMO 99014',
        ];
    }

    /** @return array<int, array{numero:int,titolo:string}> */
    public function getArchivioObbligatorioRowsProperty(): array
    {
        return [
            ['numero' => 1, 'titolo' => 'Libro dei verbali eventualmente vidimato'],
            ['numero' => 2, 'titolo' => 'Planimetria dello stabile aggiornata'],
            ['numero' => 3, 'titolo' => 'Elaborato planimetrico parti comuni'],
            ['numero' => 4, 'titolo' => 'Scheda anagrafica condominiale e riferimenti catastali'],
            ['numero' => 5, 'titolo' => 'Schede tecniche impianti e beni comuni'],
            ['numero' => 15, 'titolo' => 'Polizza global fabbricato'],
            ['numero' => 16, 'titolo' => 'Attestati di conformita e nulla osta'],
            ['numero' => 18, 'titolo' => 'Tabelle millesimali ed elaborati di calcolo'],
            ['numero' => 19, 'titolo' => 'Regolamento di condominio'],
            ['numero' => 20, 'titolo' => 'Rendiconti approvati ultimi cinque anni'],
            ['numero' => 21, 'titolo' => 'Raccolta contratti stipulati'],
            ['numero' => 22, 'titolo' => 'Servitu e diritti di terzi'],
            ['numero' => 23, 'titolo' => 'Giustificativi di spesa a conservazione lunga'],
            ['numero' => 24, 'titolo' => 'Scritture contabili e sostituto imposta'],
            ['numero' => 25, 'titolo' => 'Codice fiscale'],
            ['numero' => 26, 'titolo' => 'Partita IVA amministratore'],
            ['numero' => 27, 'titolo' => 'Chiavi dello stabile'],
            ['numero' => 28, 'titolo' => 'Timbri dello stabile'],
        ];
    }

    public function getPhysicalArchiveTypeOptionsProperty(): array
    {
        return DocumentoArchivioFisicoItem::TIPI;
    }

    public function getPhysicalArchiveParentOptionsProperty(): array
    {
        $stabileId = (int) ($this->resolveActiveStabile()?->id ?? 0);
        if ($stabileId <= 0) {
            return [];
        }

        return DocumentoArchivioFisicoItem::query()
            ->where('stabile_id', $stabileId)
            ->whereIn('tipo_item', ['busta_trasparente', 'cartella_tre_lembi', 'faldone_anelli', 'faldone_lacci', 'scatola'])
            ->orderBy('codice_univoco')
            ->get(['id', 'codice_univoco', 'titolo'])
            ->mapWithKeys(fn(DocumentoArchivioFisicoItem $item): array=> [
                (string) $item->id => trim($item->codice_univoco . ' · ' . $item->titolo),
            ])
            ->all();
    }

    public function getPhysicalArchiveDocumentOptionsProperty(): array
    {
        $stabileId = (int) ($this->resolveActiveStabile()?->id ?? 0);
        if ($stabileId <= 0) {
            return [];
        }

        return Documento::query()
            ->where('stabile_id', $stabileId)
            ->orderByDesc('data_documento')
            ->orderByDesc('id')
            ->limit(200)
            ->get(['id', 'nome_file', 'nome', 'data_documento'])
            ->mapWithKeys(function (Documento $documento): array {
                $label = trim((string) ($documento->nome_file ?: $documento->nome ?: ('Documento #' . $documento->id)));
                if ($documento->data_documento) {
                    $label .= ' · ' . $documento->data_documento->format('d-m-Y');
                }

                return [(string) $documento->id => $label];
            })
            ->all();
    }

    public function getPhysicalArchiveRowsProperty(): array
    {
        $stabileId = (int) ($this->resolveActiveStabile()?->id ?? 0);
        if ($stabileId <= 0) {
            return [];
        }

        $query = DocumentoArchivioFisicoItem::query()
            ->with(['parent', 'documento'])
            ->where('stabile_id', $stabileId)
            ->orderByDesc('data_archiviazione')
            ->orderByDesc('id');

        if (trim($this->physicalArchiveSearch) !== '') {
            $search = trim($this->physicalArchiveSearch);
            $query->where(function (Builder $builder) use ($search): void {
                $builder->where('titolo', 'like', '%' . $search . '%')
                    ->orWhere('codice_univoco', 'like', '%' . $search . '%')
                    ->orWhere('voce_titolo', 'like', '%' . $search . '%')
                    ->orWhere('note', 'like', '%' . $search . '%');
            });
        }

        if (trim($this->physicalArchiveTypeFilter) !== '') {
            $query->where('tipo_item', $this->physicalArchiveTypeFilter);
        }

        return $query
            ->limit(150)
            ->get()
            ->map(function (DocumentoArchivioFisicoItem $item): array {
                return [
                    'id'                 => (int) $item->id,
                    'codice_univoco'     => (string) $item->codice_univoco,
                    'tipo'               => (string) $item->tipo_label,
                    'titolo'             => (string) $item->titolo,
                    'voce'               => trim(collect([$item->voce_numero ? ('Voce ' . $item->voce_numero) : null, $item->voce_titolo])->filter()->implode(' · ')),
                    'data_archiviazione' => $item->data_archiviazione?->format('d-m-Y') ?: '—',
                    'parent'             => $item->parent ? trim($item->parent->codice_univoco . ' · ' . $item->parent->titolo) : 'Radice',
                    'percorso'           => (string) $item->percorso_fisico,
                    'documento'          => $item->documento ? trim((string) ($item->documento->nome_file ?: $item->documento->nome ?: ('Documento #' . $item->documento->id))): null,
                    'ubicazione'         => collect([$item->magazzino, $item->scaffale, $item->ripiano, $item->ubicazione_dettaglio])->filter()->implode(' · '),
                    'modello_etichetta'  => (string) ($item->modello_etichetta ?: '11354'),
                ];
            })
            ->all();
    }

    public function getPhysicalArchiveContainerTreeProperty(): array
    {
        $stabileId = (int) ($this->resolveActiveStabile()?->id ?? 0);
        if ($stabileId <= 0) {
            return [];
        }

        return DocumentoArchivioFisicoItem::query()
            ->where('stabile_id', $stabileId)
            ->whereNull('parent_id')
            ->orderBy('codice_univoco')
            ->get()
            ->map(function (DocumentoArchivioFisicoItem $item): array {
                return [
                    'id'             => (int) $item->id,
                    'codice_univoco' => (string) $item->codice_univoco,
                    'titolo'         => (string) $item->titolo,
                    'tipo'           => (string) $item->tipo_label,
                    'children_count' => (int) $item->children()->count(),
                ];
            })
            ->all();
    }

    public function savePhysicalArchiveEntry(): void
    {
        $user = Auth::user();
        if (! $user instanceof User) {
            Notification::make()->title('Utente non valido')->danger()->send();
            return;
        }

        $stabileId = (int) ($this->resolveActiveStabile()?->id ?? 0);
        if ($stabileId <= 0) {
            Notification::make()->title('Stabile attivo non disponibile')->danger()->send();
            return;
        }

        $titolo   = trim((string) ($this->physicalArchiveForm['titolo'] ?? ''));
        $tipoItem = trim((string) ($this->physicalArchiveForm['tipo_item'] ?? 'documento'));
        if ($titolo === '' || ! array_key_exists($tipoItem, DocumentoArchivioFisicoItem::TIPI)) {
            Notification::make()->title('Titolo e tipologia sono obbligatori')->danger()->send();
            return;
        }

        $parentId = is_numeric($this->physicalArchiveForm['parent_id'] ?? null) ? (int) $this->physicalArchiveForm['parent_id'] : null;
        $parent   = $parentId
            ? DocumentoArchivioFisicoItem::query()->where('stabile_id', $stabileId)->find($parentId)
            : null;

        $voceNumero = is_numeric($this->physicalArchiveForm['voce_numero'] ?? null) ? (int) $this->physicalArchiveForm['voce_numero'] : null;
        $voceTitolo = trim((string) ($this->physicalArchiveForm['voce_titolo'] ?? ''));
        if ($voceNumero && $voceTitolo === '') {
            $voceTitolo = collect($this->archivioObbligatorioRows)
                ->firstWhere('numero', $voceNumero)['titolo'] ?? '';
        }

        $item = DocumentoArchivioFisicoItem::query()->create([
            'stabile_id'           => $stabileId,
            'parent_id'            => $parent?->id,
            'documento_id'         => is_numeric($this->physicalArchiveForm['documento_id'] ?? null) ? (int) $this->physicalArchiveForm['documento_id'] : null,
            'voce_numero'          => $voceNumero,
            'voce_titolo'          => $voceTitolo !== '' ? $voceTitolo : null,
            'tipo_item'            => $tipoItem,
            'titolo'               => $titolo,
            'note'                 => $this->normalizeNullableText($this->physicalArchiveForm['note'] ?? null),
            'data_archiviazione'   => $this->physicalArchiveForm['data_archiviazione'] ?? now()->toDateString(),
            'supporto_fisico'      => $this->normalizeNullableText($this->physicalArchiveForm['supporto_fisico'] ?? null),
            'modello_etichetta'    => $this->normalizeNullableText($this->physicalArchiveForm['modello_etichetta'] ?? null) ?: '11354',
            'magazzino'            => $this->normalizeNullableText($this->physicalArchiveForm['magazzino'] ?? null),
            'scaffale'             => $this->normalizeNullableText($this->physicalArchiveForm['scaffale'] ?? null),
            'ripiano'              => $this->normalizeNullableText($this->physicalArchiveForm['ripiano'] ?? null),
            'ubicazione_dettaglio' => $this->normalizeNullableText($this->physicalArchiveForm['ubicazione_dettaglio'] ?? null),
            'created_by'           => (int) $user->id,
            'updated_by'           => (int) $user->id,
            'metadati'             => [
                'origine_digitale' => is_numeric($this->physicalArchiveForm['documento_id'] ?? null),
            ],
        ]);

        if ($item->documento instanceof Documento) {
            $meta                             = is_array($item->documento->metadati_archivio ?? null) ? $item->documento->metadati_archivio : [];
            $meta['physical_archive_item_id'] = (int) $item->id;
            $meta['physical_archive_code']    = (string) $item->codice_univoco;
            $meta['contenitore_numero']       = $parent?->codice_univoco;
            $meta['supporto_fisico']          = $item->supporto_fisico;
            $item->documento->forceFill([
                'metadati_archivio' => $meta,
            ])->save();
        }

        $this->initializePhysicalArchiveForms();

        Notification::make()
            ->title('Voce archivio fisico registrata')
            ->body('Codice: ' . $item->codice_univoco)
            ->success()
            ->send();
    }

    public function movePhysicalArchiveItem(): void
    {
        $stabileId = (int) ($this->resolveActiveStabile()?->id ?? 0);
        if ($stabileId <= 0) {
            Notification::make()->title('Stabile attivo non disponibile')->danger()->send();
            return;
        }

        $sourceCode = trim((string) ($this->physicalArchiveMoveForm['source_code'] ?? ''));
        $targetCode = trim((string) ($this->physicalArchiveMoveForm['target_code'] ?? ''));
        if ($sourceCode === '' || $targetCode === '') {
            Notification::make()->title('Codice sorgente e destinazione obbligatori')->danger()->send();
            return;
        }

        $source = DocumentoArchivioFisicoItem::query()->where('stabile_id', $stabileId)->where('codice_univoco', $sourceCode)->first();
        $target = DocumentoArchivioFisicoItem::query()->where('stabile_id', $stabileId)->where('codice_univoco', $targetCode)->first();

        if (! $source instanceof DocumentoArchivioFisicoItem || ! $target instanceof DocumentoArchivioFisicoItem) {
            Notification::make()->title('Codici archivio non trovati')->danger()->send();
            return;
        }

        if ((int) $source->id === (int) $target->id) {
            Notification::make()->title('La destinazione deve essere diversa dalla sorgente')->danger()->send();
            return;
        }

        $source->forceFill([
            'parent_id'  => (int) $target->id,
            'updated_by' => Auth::id(),
        ])->save();

        $this->physicalArchiveMoveForm = [
            'source_code' => '',
            'target_code' => '',
        ];

        Notification::make()
            ->title('Movimentazione registrata')
            ->body($source->codice_univoco . ' → ' . $target->codice_univoco)
            ->success()
            ->send();
    }

    public function getVisibleFolderRowsProperty(): array
    {
        $user = Auth::user();
        if (! $user instanceof User) {
            return [];
        }

        $stabileId = $this->resolveActiveStabile()?->id;

        return $this->getVisibilityService()
            ->scopeVisibleCartelle(DocumentoArchivioCartella::query()->with('parent', 'stabile'), $user, $stabileId ? (int) $stabileId : null)
            ->orderBy('sort_order')
            ->orderBy('nome')
            ->get()
            ->map(function (DocumentoArchivioCartella $folder): array {
                $roles  = collect($folder->visibility_roles ?? [])->map(fn($value): string => (string) $value)->filter()->values()->all();
                $groups = collect($folder->visibility_groups ?? [])->map(fn($value): string => (string) $value)->filter()->values()->all();
                $users  = collect($folder->allowed_user_ids ?? [])->filter(fn($value): bool => is_numeric($value) && (int) $value > 0)->map(fn($value): int => (int) $value)->all();

                $userNames = $users === []
                    ? []
                    : User::query()->whereIn('id', $users)->orderBy('name')->pluck('name')->map(fn($value): string => (string) $value)->all();

                return [
                    'id'              => (int) $folder->id,
                    'nome'            => (string) $folder->nome,
                    'path'            => (string) ($folder->display_path ?: $folder->nome),
                    'stabile'         => (string) ($folder->stabile?->denominazione ?: ('Stabile #' . (int) $folder->stabile_id)),
                    'scope'           => (string) ($folder->visibility_scope ?: 'interno'),
                    'roles'           => $roles,
                    'groups'          => $groups,
                    'users'           => $userNames,
                    'documents_count' => (int) $folder->documenti()->count(),
                ];
            })
            ->all();
    }

    public function getMnemonicCodeHintProperty(): ?string
    {
        $stabile = $this->resolveActiveStabile();
        if (! $stabile instanceof Stabile) {
            return null;
        }

        $label   = Str::upper((string) ($stabile->denominazione ?? 'STABILE'));
        $letters = preg_replace('/[^A-Z]/', '', Str::ascii($label)) ?: 'STB';
        $digits  = preg_replace('/\D/', '', $label);
        $prefix  = str_pad(substr($letters, 0, 3), 3, 'X');
        $suffix  = str_pad(substr($digits !== '' ? $digits : (string) $stabile->id, -5), 5, '0', STR_PAD_LEFT);

        return $prefix . $suffix;
    }

    public function getProtocolloComunicazioniStatsProperty(): array
    {
        $query = $this->getProtocolloComunicazioniQuery();

        return [
            'totale'      => (clone $query)->count(),
            'con_pdf'     => (clone $query)
                ->where(function (Builder $builder): void {
                    $builder->whereNotNull('percorso_file')
                        ->orWhereNotNull('path_file');
                })
                ->count(),
            'questo_mese' => (clone $query)
                ->whereDate('created_at', '>=', now()->startOfMonth()->toDateString())
                ->count(),
            'categorie'   => (clone $query)
                ->reorder()
                ->select('tipo_documento')
                ->distinct()
                ->count('tipo_documento'),
        ];
    }

    public function getProtocolloComunicazioniCategoryOptionsProperty(): array
    {
        $visibleCategories = (clone $this->getProtocolloComunicazioniQuery())
            ->reorder()
            ->select('tipo_documento')
            ->distinct()
            ->pluck('tipo_documento')
            ->map(fn($value): string => trim((string) $value))
            ->filter()
            ->values()
            ->all();

        $labels = $this->getCategorieOptions();

        return collect($visibleCategories)
            ->mapWithKeys(fn(string $value): array=> [$value => $labels[$value] ?? Str::headline($value)])
            ->all();
    }

    public function getProtocolloComunicazioniRowsProperty(): array
    {
        $limit  = $this->protocolloView === 'list' ? 80 : 18;
        $labels = $this->getCategorieOptions();

        return $this->getProtocolloComunicazioniQuery()
            ->with('cartellaArchivio')
            ->limit($limit)
            ->get()
            ->map(function (Documento $documento) use ($labels): array {
                $openUrl = route('filament.documenti.download', $documento) . '?inline=1';
                $tipo    = trim((string) ($documento->tipo_documento ?? ''));

                return [
                    'id'                => (int) $documento->id,
                    'protocollo'        => trim((string) ($documento->numero_protocollo ?: 'DOC-' . $documento->id)),
                    'titolo'            => trim((string) ($documento->nome ?: $documento->nome_file ?: ('Documento #' . $documento->id))),
                    'descrizione'       => trim((string) ($documento->descrizione ?: Str::limit((string) ($documento->contenuto_ocr ?? ''), 140, '...'))),
                    'categoria'         => $labels[$tipo] ?? ($tipo !== '' ? Str::headline($tipo) : 'Protocollo generale'),
                    'fornitore'         => trim((string) ($documento->fornitore ?? '')),
                    'data'              => $documento->data_documento?->format('d/m/Y')
                        ?: ($documento->created_at?->format('d/m/Y') ?: '—'),
                    'cartella'          => trim((string) ($documento->cartellaArchivio?->nome ?? 'Protocollo generale')),
                    'archive_reference' => trim((string) ($documento->archive_reference ?? '')),
                    'has_pdf'           => $this->hasPdf($documento),
                    'preview_url'       => $openUrl,
                    'download_url'      => route('filament.documenti.download', $documento),
                    'print_url'         => $openUrl,
                ];
            })
            ->all();
    }

    private function getDocumentoFormSchema(): array
    {
        return [
            Select::make('stabile_id')
                ->label('Stabile')
                ->options(fn() => $this->getStabiliOptions())
                ->default(fn() => $this->getDefaultStabileId())
                ->searchable()
                ->live()
                ->required(),
            Select::make('cartella_archivio_id')
                ->label('Cartella archivio')
                ->options(fn(callable $get): array=> $this->getArchivioFolderOptions((int) ($get('stabile_id') ?: 0)))
                ->searchable()
                ->nullable(),
            Select::make('categoria')
                ->label('Categoria protocollo')
                ->options($this->getCategorieOptions())
                ->required(),
            Select::make('archivio_classe')
                ->label('Classe archivio condominiale')
                ->options($this->getArchivioClasseOptions())
                ->searchable()
                ->required(),
            TextInput::make('titolo')
                ->label('Titolo')
                ->required()
                ->maxLength(255),
            Textarea::make('descrizione')
                ->label('Descrizione')
                ->rows(4),
            TextInput::make('fornitore')
                ->label('Fornitore / Ente / Compagnia')
                ->maxLength(255),
            DatePicker::make('data_documento')
                ->label('Data documento')
                ->default(now())
                ->required(),
            DatePicker::make('data_scadenza')
                ->label('Data scadenza')
                ->nullable(),
            TextInput::make('importo')
                ->label('Importo (opzionale)')
                ->numeric()
                ->step(0.01)
                ->minValue(0)
                ->nullable(),
            Select::make('movimento_contabile_id')
                ->label('Movimento contabile (opzionale)')
                ->options(fn(callable $get) => $this->getMovimentiOptions((int) ($get('stabile_id') ?: 0)))
                ->searchable()
                ->nullable(),
            TextInput::make('faldone')
                ->label('Faldone (archiviazione fisica)')
                ->placeholder('Es. CONTR-2024')
                ->maxLength(50)
                ->nullable(),
            Select::make('supporto_fisico')
                ->label('Supporto fisico')
                ->options(array_combine($this->archivioFisicoTypes, $this->archivioFisicoTypes))
                ->searchable()
                ->nullable(),
            Select::make('modello_etichetta')
                ->label('Modello etichetta')
                ->options($this->getModelliEtichettaOptions())
                ->default('11354')
                ->native(false)
                ->nullable(),
            TextInput::make('busta_numero')
                ->label('Busta n.')
                ->maxLength(30),
            TextInput::make('fascicolo_numero')
                ->label('Fascicolo n.')
                ->maxLength(30),
            TextInput::make('contenitore_numero')
                ->label('Contenitore / faldone')
                ->placeholder('Es. 12')
                ->maxLength(30),
            DatePicker::make('periodo_riferimento_da')
                ->label('Periodo dal'),
            DatePicker::make('periodo_riferimento_a')
                ->label('Periodo al'),
            Select::make('visibility_scope')
                ->label('Visibilità')
                ->options($this->getVisibilityScopeOptions())
                ->default('interno')
                ->native(false)
                ->required(),
            Select::make('visibility_roles')
                ->label('Ruoli ammessi')
                ->options($this->getVisibilityRoleOptions())
                ->multiple()
                ->native(false),
            Select::make('visibility_groups')
                ->label('Gruppi audience')
                ->options(array_combine($this->audienceGroups, $this->audienceGroups))
                ->multiple()
                ->native(false),
            Select::make('allowed_user_ids')
                ->label('Utenti specifici ammessi')
                ->options($this->getCollaboratorUserOptions())
                ->multiple()
                ->native(false)
                ->searchable(),
            FileUpload::make('pdf')
                ->label('PDF')
                ->disk('local')
                ->acceptedFileTypes(['application/pdf'])
                ->required(),
        ];
    }

    private function getArchivioFolderFormSchema(): array
    {
        return [
            Select::make('stabile_id')
                ->label('Stabile')
                ->options(fn(): array=> $this->getStabiliOptions())
                ->default(fn(): ?int => $this->getDefaultStabileId())
                ->searchable()
                ->live()
                ->required(),
            Select::make('parent_id')
                ->label('Cartella padre')
                ->options(fn(callable $get): array=> $this->getArchivioFolderOptions((int) ($get('stabile_id') ?: 0)))
                ->searchable()
                ->nullable(),
            TextInput::make('nome')
                ->label('Nome cartella')
                ->required()
                ->maxLength(160),
            TextInput::make('codice')
                ->label('Codice cartella')
                ->maxLength(80),
            Select::make('visibility_scope')
                ->label('Visibilità')
                ->options($this->getVisibilityScopeOptions())
                ->default('interno')
                ->native(false)
                ->required(),
            Select::make('visibility_roles')
                ->label('Ruoli ammessi')
                ->options($this->getVisibilityRoleOptions())
                ->multiple()
                ->native(false),
            Select::make('visibility_groups')
                ->label('Gruppi audience')
                ->options(array_combine($this->audienceGroups, $this->audienceGroups))
                ->multiple()
                ->native(false),
            Select::make('allowed_user_ids')
                ->label('Utenti specifici')
                ->options($this->getCollaboratorUserOptions())
                ->multiple()
                ->native(false),
            Textarea::make('note')
                ->label('Note cartella')
                ->rows(3),
        ];
    }

    private function getStabiliOptions(): array
    {
        $user = Auth::user();
        if (! $user instanceof User) {
            return [];
        }

        if ($user->hasAnyRole(['super-admin', 'admin'])) {
            return Stabile::query()
                ->orderBy('denominazione')
                ->limit(500)
                ->get(['id', 'denominazione'])
                ->mapWithKeys(fn(Stabile $s) => [(string) $s->id => (($s->denominazione ?: ('Stabile #' . $s->id)))])
                ->all();
        }

        $allowed = StabileContext::accessibleStabili($user);
        return $allowed
            ->sortBy(fn(Stabile $s) => $s->denominazione)
            ->take(500)
            ->mapWithKeys(fn(Stabile $s) => [(string) $s->id => (($s->denominazione ?: ('Stabile #' . $s->id)))])
            ->all();
    }

    private function initializePhysicalArchiveForms(): void
    {
        $this->physicalArchiveForm = [
            'data_archiviazione'   => now()->toDateString(),
            'voce_numero'          => null,
            'voce_titolo'          => '',
            'titolo'               => '',
            'note'                 => '',
            'tipo_item'            => 'documento',
            'supporto_fisico'      => 'Busta trasparente con anelli da archiviare',
            'parent_id'            => null,
            'documento_id'         => null,
            'magazzino'            => '',
            'scaffale'             => '',
            'ripiano'              => '',
            'ubicazione_dettaglio' => '',
            'modello_etichetta'    => '11354',
        ];

        $this->physicalArchiveMoveForm = [
            'source_code' => '',
            'target_code' => '',
        ];
    }

    private function getDefaultStabileId(): ?int
    {
        $user = Auth::user();
        if (! $user instanceof User) {
            return null;
        }

        $activeId = StabileContext::getActiveStabileId($user);
        if (is_int($activeId) && $activeId > 0) {
            return $activeId;
        }

        return StabileContext::accessibleStabili($user)->first()?->id;
    }

    private function getVisibilityService(): DocumentoArchivioVisibilityService
    {
        return $this->visibilityService ??= app(DocumentoArchivioVisibilityService::class);
    }

    private function getVisibilityScopeOptions(): array
    {
        return [
            'interno'    => 'Interno studio',
            'studio'     => 'Studio completo',
            'restricted' => 'Limitato a ruoli / utenti',
        ];
    }

    private function getVisibilityRoleOptions(): array
    {
        return [
            'super-admin'    => 'Super admin',
            'admin'          => 'Admin',
            'amministratore' => 'Amministratore',
            'collaboratore'  => 'Collaboratore',
        ];
    }

    private function getCollaboratorUserOptions(): array
    {
        return User::query()
            ->role(['super-admin', 'admin', 'amministratore', 'collaboratore'])
            ->orderBy('name')
            ->limit(300)
            ->get(['id', 'name', 'email'])
            ->mapWithKeys(function (User $user): array {
                $label = trim((string) $user->name);
                if (trim((string) $user->email) !== '') {
                    $label .= ' <' . trim((string) $user->email) . '>';
                }

                return [(string) $user->id => $label !== '' ? $label : ('Utente #' . (int) $user->id)];
            })
            ->all();
    }

    private function getArchivioFolderOptions(int $stabileId): array
    {
        if ($stabileId <= 0) {
            return [];
        }

        return DocumentoArchivioCartella::query()
            ->where('stabile_id', $stabileId)
            ->where('is_active', true)
            ->orderBy('sort_order')
            ->orderBy('nome')
            ->get(['id', 'nome', 'percorso_logico'])
            ->mapWithKeys(function (DocumentoArchivioCartella $folder): array {
                $label = trim((string) ($folder->percorso_logico ?: $folder->nome));

                return [(string) $folder->id => $label !== '' ? $label : ('Cartella #' . (int) $folder->id)];
            })
            ->all();
    }

    private function syncInvoiceFolders(): void
    {
        $stabile = $this->resolveActiveStabile();
        if (! $stabile instanceof Stabile) {
            $this->currentFolderId = null;
            return;
        }

        $root = $this->ensureInvoiceRootFolder((int) $stabile->id);
        if (! $root instanceof DocumentoArchivioCartella) {
            return;
        }

        Documento::query()
            ->where('stabile_id', $stabile->id)
            ->where('tipo_documento', 'fattura')
            ->orderBy('data_documento')
            ->orderBy('id')
            ->get(['id', 'data_documento', 'cartella_archivio_id'])
            ->each(function (Documento $documento) use ($stabile, $root): void {
                $year       = (int) (($documento->data_documento?->format('Y')) ?: now()->format('Y'));
                $yearFolder = $this->ensureInvoiceYearFolder((int) $stabile->id, $root, $year);
                if (! $yearFolder instanceof DocumentoArchivioCartella) {
                    return;
                }

                if ((int) ($documento->cartella_archivio_id ?? 0) !== (int) $yearFolder->id) {
                    $documento->forceFill([
                        'cartella_archivio_id' => (int) $yearFolder->id,
                    ])->save();
                }
            });

        if ($this->currentFolderId) {
            $exists = DocumentoArchivioCartella::query()
                ->whereKey($this->currentFolderId)
                ->where('stabile_id', $stabile->id)
                ->exists();

            if (! $exists) {
                $this->currentFolderId = null;
            }
        }
    }

    private function ensureInvoiceRootFolder(int $stabileId): ?DocumentoArchivioCartella
    {
        if ($stabileId <= 0) {
            return null;
        }

        return DocumentoArchivioCartella::query()->firstOrCreate(
            [
                'stabile_id' => $stabileId,
                'parent_id'  => null,
                'slug'       => 'fatture-pdf',
            ],
            [
                'nome'             => 'fatture_PDF',
                'codice'           => 'FATTURE',
                'percorso_logico'  => 'fatture_PDF',
                'visibility_scope' => 'interno',
                'created_by'       => Auth::id(),
                'updated_by'       => Auth::id(),
            ]
        );
    }

    private function ensureInvoiceYearFolder(int $stabileId, DocumentoArchivioCartella $root, int $year): ?DocumentoArchivioCartella
    {
        if ($stabileId <= 0 || $year < 2000) {
            return null;
        }

        return DocumentoArchivioCartella::query()->firstOrCreate(
            [
                'stabile_id' => $stabileId,
                'parent_id'  => (int) $root->id,
                'slug'       => (string) $year,
            ],
            [
                'nome'             => (string) $year,
                'codice'           => 'FATT-' . $year,
                'percorso_logico'  => trim((string) $root->nome) . '/' . $year,
                'visibility_scope' => 'interno',
                'created_by'       => Auth::id(),
                'updated_by'       => Auth::id(),
            ]
        );
    }

    private function formatPhysicalArchiveLocation(Documento $record): string
    {
        $meta = is_array($record->metadati_archivio ?? null) ? $record->metadati_archivio : [];

        $parts = array_filter([
            $this->normalizeNullableText($meta['supporto_fisico'] ?? null),
            $this->normalizeNullableText($meta['contenitore_numero'] ?? null),
            $this->normalizeNullableText($meta['busta_numero'] ?? null) ? 'Busta ' . $this->normalizeNullableText($meta['busta_numero'] ?? null) : null,
            $this->normalizeNullableText($meta['fascicolo_numero'] ?? null) ? 'Fascicolo ' . $this->normalizeNullableText($meta['fascicolo_numero'] ?? null) : null,
        ]);

        return $parts === [] ? '—' : implode(' · ', $parts);
    }

    private function normalizeHubTab(string $tab): string
    {
        $allowed = ['protocollo-comunicazioni', 'archivio-digitale', 'template-drive', 'archivio-fisico', 'permessi'];

        return in_array($tab, $allowed, true) ? $tab : 'protocollo-comunicazioni';
    }

    private function getProtocolloComunicazioniQuery(): Builder
    {
        $user = Auth::user();
        if (! $user instanceof User) {
            return Documento::query()->whereRaw('1 = 0');
        }

        $query = $this->getVisibilityService()
            ->scopeVisibleDocumenti(Documento::query(), $user)
            ->where(function (Builder $builder): void {
                $builder->whereNull('tipo_documento')
                    ->orWhere('tipo_documento', '!=', 'fattura');
            });

        $stabileId = (int) ($this->resolveActiveStabile()?->id ?? 0);
        if ($stabileId > 0) {
            $query->where('stabile_id', $stabileId);
        }

        $category = trim($this->protocolloCategory);
        if ($category !== '') {
            $query->where('tipo_documento', $category);
        }

        $search = trim($this->protocolloSearch);
        if ($search !== '') {
            $query->where(function (Builder $builder) use ($search): void {
                $builder->where('numero_protocollo', 'like', '%' . $search . '%')
                    ->orWhere('nome', 'like', '%' . $search . '%')
                    ->orWhere('nome_file', 'like', '%' . $search . '%')
                    ->orWhere('descrizione', 'like', '%' . $search . '%')
                    ->orWhere('fornitore', 'like', '%' . $search . '%')
                    ->orWhere('archive_reference', 'like', '%' . $search . '%');
            });
        }

        return $query
            ->orderByDesc('data_documento')
            ->orderByDesc('created_at')
            ->orderByDesc('id');
    }

    private function resolveActiveStabile(): ?Stabile
    {
        $user = Auth::user();
        if (! $user instanceof User) {
            return null;
        }

        return StabileContext::getActiveStabile($user);
    }

    private function getMovimentiOptions(int $stabileId): array
    {
        if ($stabileId <= 0) {
            return [];
        }
        if (! class_exists(MovimentoContabile::class)) {
            return [];
        }

        return MovimentoContabile::query()
            ->where('stabile_id', $stabileId)
            ->orderByDesc('data_movimento')
            ->orderByDesc('id')
            ->limit(200)
            ->get(['id', 'descrizione', 'data_movimento', 'importo'])
            ->mapWithKeys(function (MovimentoContabile $m) {
                $label = '#' . $m->id;
                if ($m->data_movimento) {
                    $label .= ' ' . $m->data_movimento->format('d-m-Y');
                }
                if (is_string($m->descrizione) && trim($m->descrizione) !== '') {
                    $label .= ' — ' . trim($m->descrizione);
                }
                if ($m->importo !== null) {
                    $label .= ' — €' . number_format((float) $m->importo, 2, ',', '.');
                }
                return [(string) $m->id => $label];
            })
            ->all();
    }

    private function createArchivioFolder(array $data): void
    {
        $user = Auth::user();
        if (! $user instanceof User) {
            Notification::make()->title('Utente non valido')->danger()->send();
            return;
        }

        $stabileId = isset($data['stabile_id']) && is_numeric($data['stabile_id']) ? (int) $data['stabile_id'] : 0;
        if ($stabileId <= 0) {
            Notification::make()->title('Stabile obbligatorio')->danger()->send();
            return;
        }

        $allowedIds = StabileContext::accessibleStabili($user)->pluck('id')->map(fn($value): int => (int) $value)->all();
        if (! in_array($stabileId, $allowedIds, true) && ! $user->hasAnyRole(['super-admin', 'admin'])) {
            Notification::make()->title('Stabile non accessibile')->danger()->send();
            return;
        }

        $name = trim((string) ($data['nome'] ?? ''));
        if ($name === '') {
            Notification::make()->title('Nome cartella obbligatorio')->danger()->send();
            return;
        }

        $parentId = isset($data['parent_id']) && is_numeric($data['parent_id']) ? (int) $data['parent_id'] : null;
        $parent   = $parentId
            ? DocumentoArchivioCartella::query()->where('stabile_id', $stabileId)->find($parentId)
            : null;

        $slug = Str::slug($name);
        if ($slug === '') {
            $slug = 'cartella-' . now()->format('YmdHis');
        }

        $logicalPath = collect([
            $parent?->percorso_logico,
            $name,
        ])->filter(fn($value): bool => is_string($value) && trim($value) !== '')->implode('/');

        DocumentoArchivioCartella::query()->create([
            'stabile_id'        => $stabileId,
            'parent_id'         => $parent?->id,
            'nome'              => $name,
            'slug'              => $slug,
            'codice'            => trim((string) ($data['codice'] ?? '')) ?: null,
            'percorso_logico'   => $logicalPath !== '' ? $logicalPath : $name,
            'visibility_scope'  => (string) ($data['visibility_scope'] ?? 'interno'),
            'visibility_roles'  => $this->normalizeStringArray($data['visibility_roles'] ?? []),
            'visibility_groups' => $this->normalizeStringArray($data['visibility_groups'] ?? []),
            'allowed_user_ids'  => $this->normalizeIntArray($data['allowed_user_ids'] ?? []),
            'note'              => trim((string) ($data['note'] ?? '')) ?: null,
            'created_by'        => (int) $user->id,
            'updated_by'        => (int) $user->id,
        ]);

        Notification::make()->title('Cartella archivio creata')->success()->send();
    }

    private function createDocumentoFromForm(array $data, bool $isDemo): void
    {
        $user = Auth::user();
        if (! $user instanceof User) {
            Notification::make()->title('Utente non valido')->danger()->send();
            return;
        }

        $stabileId = (int) ($data['stabile_id'] ?? 0);
        if ($stabileId <= 0) {
            Notification::make()->title('Stabile obbligatorio')->danger()->send();
            return;
        }

        $categoria = (string) ($data['categoria'] ?? 'altro');
        $titolo    = (string) ($data['titolo'] ?? '');
        if (trim($titolo) === '') {
            Notification::make()->title('Titolo obbligatorio')->danger()->send();
            return;
        }

        $dataDocumento = $data['data_documento'] ?? null;
        $year          = null;
        if ($dataDocumento instanceof \DateTimeInterface) {
            $year = (int) $dataDocumento->format('Y');
        } elseif (is_string($dataDocumento) && trim($dataDocumento) !== '') {
            $raw = trim($dataDocumento);
            foreach (['Y-m-d', 'd-m-Y', 'd/m/Y', 'Y/m/d'] as $fmt) {
                try {
                    $dt = Carbon::createFromFormat($fmt, $raw);
                    if ($dt) {
                        $year = (int) $dt->format('Y');
                        break;
                    }
                } catch (\Throwable) {
                    // try next
                }
            }
            if ($year === null) {
                try {
                    $year = (int) Carbon::parse($raw)->format('Y');
                } catch (\Throwable) {
                    $year = null;
                }
            }
        }
        if (! is_int($year) || $year < 2000 || $year > 2100) {
            $year = (int) now()->format('Y');
        }

        $protocollo = $this->generateProtocollo($categoria, $year);

        $storedPath = (string) ($data['pdf'] ?? '');
        if ($storedPath === '') {
            Notification::make()->title('PDF obbligatorio')->danger()->send();
            return;
        }

        $resolvedFolderId = $this->resolveDefaultFolderIdForDocument($stabileId, $categoria, $year, $data['cartella_archivio_id'] ?? null);

        // Rinomina il file su storage in modo ordinato
        $finalDir  = 'documenti/stabili/ID-' . $stabileId . '/' . $year;
        $finalName = $this->buildDocumentStorageFilename($categoria, $dataDocumento, $protocollo, (string) ($data['fornitore'] ?? ''), $titolo);
        $finalPath = $finalDir . '/' . $finalName;

        try {
            if (Storage::disk('local')->exists($storedPath)) {
                $bytes = Storage::disk('local')->get($storedPath);
                Storage::disk('local')->put($finalPath, $bytes);
                Storage::disk('local')->delete($storedPath);
            }
        } catch (\Throwable) {
            // best-effort
        }

        $size = null;
        try {
            if (Storage::disk('local')->exists($finalPath)) {
                $size = Storage::disk('local')->size($finalPath);
            }
        } catch (\Throwable) {
            // ignore
        }

        $note    = '';
        $faldone = trim((string) ($data['faldone'] ?? ''));
        if ($faldone !== '') {
            $note = 'Faldone: ' . $faldone;
        }

        $tipologia        = $this->mapCategoriaToTipologia($categoria);
        $archivioClasse   = trim((string) ($data['archivio_classe'] ?? ''));
        $archiveReference = $this->buildArchiveReference($stabileId, $categoria, $year, $data);

        $doc = Documento::query()->create([
            'documentable_type'      => null,
            'documentable_id'        => null,
            'stabile_id'             => $stabileId,
            'cartella_archivio_id'   => $resolvedFolderId,
            'utente_id'              => (int) $user->id,
            'nome'                   => $titolo,
            'descrizione'            => (string) ($data['descrizione'] ?? ''),
            'fornitore'              => (string) ($data['fornitore'] ?? ''),
            'tipologia'              => $tipologia,
            'tipo_documento'         => $categoria,
            'data_documento'         => $dataDocumento,
            'data_scadenza'          => $data['data_scadenza'] ?? null,
            'importo_collegato'      => $data['importo'] ?? null,
            'movimento_contabile_id' => $data['movimento_contabile_id'] ?? null,
            'numero_protocollo'      => $protocollo,
            'archive_reference'      => $archiveReference,
            'nome_file'              => $finalName,
            'mime_type'              => 'application/pdf',
            'path_file'              => $finalPath,
            'percorso_file'          => $finalPath,
            'estensione'             => 'pdf',
            'dimensione_file'        => $size,
            'metadati_archivio'      => [
                'classe'             => $archivioClasse !== '' ? $archivioClasse : null,
                'classe_label'       => $this->getArchivioClasseOptions()[$archivioClasse] ?? null,
                'supporto_fisico'    => $this->normalizeNullableText($data['supporto_fisico'] ?? null),
                'modello_etichetta'  => $this->normalizeNullableText($data['modello_etichetta'] ?? null),
                'busta_numero'       => $this->normalizeNullableText($data['busta_numero'] ?? null),
                'fascicolo_numero'   => $this->normalizeNullableText($data['fascicolo_numero'] ?? null),
                'contenitore_numero' => $this->normalizeNullableText($data['contenitore_numero'] ?? null),
                'periodo_da'         => $data['periodo_riferimento_da'] ?? null,
                'periodo_a'          => $data['periodo_riferimento_a'] ?? null,
                'codice_etichetta'   => $archiveReference,
                'qr_ready'           => true,
                'nfc_ready'          => true,
            ],
            'visibility_scope'       => (string) ($data['visibility_scope'] ?? 'interno'),
            'visibility_roles'       => $this->normalizeStringArray($data['visibility_roles'] ?? []),
            'visibility_groups'      => $this->normalizeStringArray($data['visibility_groups'] ?? []),
            'allowed_user_ids'       => $this->normalizeIntArray($data['allowed_user_ids'] ?? []),
            'data_upload'            => now(),
            'note'                   => $note,
            'is_demo'                => $isDemo,
        ]);

        // Estrai testo per ricerca (best-effort)
        try {
            app(PdfTextExtractionService::class)->extractAndStore($doc, false);
        } catch (\Throwable) {
            // ignore
        }

        Notification::make()
            ->title('Documento registrato')
            ->body('Protocollo: ' . $protocollo . ' · Archivio: ' . $archiveReference)
            ->success()
            ->send();
    }

    private function createDocumentoDemoContrattoAscensori(int $stabileId, string $faldone): void
    {
        $user = Auth::user();
        if (! $user instanceof User) {
            Notification::make()->title('Utente non valido')->danger()->send();
            return;
        }

        $year       = 2024;
        $protocollo = $this->generateProtocollo('contratto', $year);

        $titolo      = 'Contratto Manutenzione Ascensori 2024';
        $descrizione = 'Contratto annuale per manutenzione impianti ascensore con Acme Elevators Srl.';

        $html  = '<h1>' . e($titolo) . '</h1>';
        $html .= '<p><strong>Protocollo:</strong> ' . e($protocollo) . '</p>';
        $html .= '<p>' . e($descrizione) . '</p>';
        $html .= '<hr>';
        $html .= '<p><strong>Fornitore:</strong> Acme Elevators Srl</p>';
        $html .= '<p><strong>Dal:</strong> 01/01/2024 <strong>Al:</strong> 31/12/2024</p>';
        $html .= '<p><strong>Totale annuo:</strong> € 2.400,00</p>';
        $html .= '<p><strong>Modalità pagamento:</strong> Trimestrale</p>';
        $html .= '<p><strong>Data stipula:</strong> 15/12/2023</p>';

        $dompdf = new Dompdf();
        $dompdf->loadHtml('<html><body style="font-family: DejaVu Sans, Arial, sans-serif;">' . $html . '</body></html>');
        $dompdf->setPaper('A4');
        $dompdf->render();
        $pdfBytes = $dompdf->output();

        $finalDir  = 'documenti/stabili/ID-' . $stabileId . '/' . $year;
        $finalName = $protocollo . '_contratto_ascensori_2024.pdf';
        $finalPath = $finalDir . '/' . $finalName;

        Storage::disk('local')->put($finalPath, $pdfBytes);

        $size = null;
        try {
            $size = Storage::disk('local')->size($finalPath);
        } catch (\Throwable) {
            // ignore
        }

        $note    = '';
        $faldone = trim($faldone);
        if ($faldone !== '') {
            $note = 'Faldone: ' . $faldone;
        } else {
            $note = 'Faldone: CONTR-2024';
        }

        $doc = Documento::query()->create([
            'stabile_id'        => $stabileId,
            'utente_id'         => (int) $user->id,
            'nome'              => $titolo,
            'descrizione'       => $descrizione,
            'fornitore'         => 'Acme Elevators Srl',
            'tipologia'         => 'contratto',
            'tipo_documento'    => 'contratto',
            'data_documento'    => '2023-12-15',
            'data_scadenza'     => '2024-12-31',
            'importo_collegato' => 2400.00,
            'numero_protocollo' => $protocollo,
            'nome_file'         => $finalName,
            'mime_type'         => 'application/pdf',
            'path_file'         => $finalPath,
            'percorso_file'     => $finalPath,
            'estensione'        => 'pdf',
            'dimensione_file'   => $size,
            'visibility_scope'  => 'interno',
            'data_upload'       => now(),
            'note'              => $note,
            'is_demo'           => true,
        ]);

        try {
            app(PdfTextExtractionService::class)->extractAndStore($doc, true);
        } catch (\Throwable) {
            // ignore
        }

        Notification::make()
            ->title('Demo creato')
            ->body('Protocollo: ' . $protocollo)
            ->success()
            ->send();
    }

    private function generateProtocollo(string $categoria, int $year): string
    {
        $categoria = strtolower(trim($categoria));
        $prefissi  = [
            'contratto'     => 'CONTR',
            'assicurazione' => 'ASSIC',
            'certificato'   => 'CERT',
            'planimetria'   => 'PLAN',
            'fascicolo'     => 'FASC',
            'anagrafica'    => 'ANAG',
            'tabella'       => 'TABM',
            'regolamento'   => 'REGO',
            'scritture'     => 'CONT',
            'chiavi'        => 'CHIA',
            'timbri'        => 'TIMB',
            'preventivo'    => 'PREV',
            // Importante: i protocolli fattura devono essere per-anno.
            // Usiamo FT come prefisso compatto e compatibile con l'archiviazione.
            'fattura'       => 'FT',
            'verbale'       => 'VERB',
            'altro'         => 'DOC',
        ];

        $pref = $prefissi[$categoria] ?? 'DOC';

        $ultimo = Documento::query()
            ->whereNotNull('numero_protocollo')
            ->where(function ($q) use ($pref, $year) {
                $q->where('numero_protocollo', 'like', $pref . '-' . $year . '-%');
                // Compatibilità: alcuni documenti legacy potrebbero avere prefisso FATT.
                if ($pref === 'FT') {
                    $q->orWhere('numero_protocollo', 'like', 'FATT-' . $year . '-%');
                }
            })
            ->orderBy('numero_protocollo', 'desc')
            ->first(['numero_protocollo']);

        $progressivo = 1;
        if ($ultimo && is_string($ultimo->numero_protocollo)) {
            $parts = explode('-', $ultimo->numero_protocollo);
            $last  = (int) (end($parts) ?: 0);
            if ($last > 0) {
                $progressivo = $last + 1;
            }
        }

        return sprintf('%s-%d-%03d', $pref, $year, $progressivo);
    }

    private function buildArchiveReference(int $stabileId, string $categoria, int $year, array $data): string
    {
        $stabile  = Stabile::query()->find($stabileId);
        $mnemonic = $this->mnemonicCodeHint;

        if (! $mnemonic && $stabile instanceof Stabile) {
            $label    = Str::upper((string) ($stabile->denominazione ?? 'STABILE'));
            $letters  = preg_replace('/[^A-Z]/', '', Str::ascii($label)) ?: 'STB';
            $digits   = preg_replace('/\D/', '', $label);
            $mnemonic = str_pad(substr($letters, 0, 3), 3, 'X') . str_pad(substr($digits !== '' ? $digits : (string) $stabile->id, -5), 5, '0', STR_PAD_LEFT);
        }

        $contenitore = $this->normalizeNullableText($data['contenitore_numero'] ?? $data['faldone'] ?? null) ?: '00';
        $fascicolo   = $this->normalizeNullableText($data['fascicolo_numero'] ?? null) ?: '00/' . $year;

        return implode(' · ', array_filter([
            $mnemonic ?: 'STB00000',
            strtoupper($categoria),
            (string) $year,
            'BUSTA ' . $contenitore,
            'FASC ' . $fascicolo,
        ]));
    }

    private function buildDocumentStorageFilename(string $categoria, mixed $dataDocumento, string $protocollo, string $fornitore, string $titolo): string
    {
        $safeDate = '00000000';
        try {
            if ($dataDocumento instanceof \DateTimeInterface) {
                $safeDate = $dataDocumento->format('Ymd');
            } elseif (is_string($dataDocumento) && trim($dataDocumento) !== '') {
                $safeDate = Carbon::parse(trim($dataDocumento))->format('Ymd');
            }
        } catch (\Throwable) {
            $safeDate = now()->format('Ymd');
        }

        $sourceLabel = $categoria === 'fattura'
            ? ($fornitore !== '' ? $fornitore : $titolo)
            : $titolo;

        $safeLabel      = trim((string) Str::of($sourceLabel)->ascii()->replaceMatches('/[^A-Za-z0-9]+/', ' ')->squish());
        $safeLabel      = str_replace(' ', '_', Str::limit($safeLabel !== '' ? $safeLabel : 'documento', 60, ''));
        $safeProtocollo = str_replace(['/', ' '], '-', trim($protocollo));

        if ($categoria === 'fattura') {
            return $safeDate . '_' . $safeProtocollo . '_' . Str::lower($safeLabel) . '.pdf';
        }

        return $safeProtocollo . '_' . Str::lower($safeLabel) . '.pdf';
    }

    private function hasPdf(Documento $doc): bool
    {
        $p = (string) ($doc->percorso_file ?: ($doc->path_file ?: ''));
        return $p !== '' && str_ends_with(strtolower($p), '.pdf');
    }

    private function mapCategoriaToTipologia(string $categoria): string
    {
        $categoria = strtolower(trim($categoria));

        // `documenti.tipologia` è un enum: manteniamoci sui valori previsti.
        return match ($categoria) {
            'contratto'   => 'contratto',
            'certificato' => 'certificato',
            'preventivo'  => 'preventivo',
            'fattura'     => 'fattura',
            'verbale'     => 'verbale',
            default       => 'altro',
        };
    }

    private function resolveFolderIdForDocument(int $stabileId, mixed $folderId): ?int
    {
        if (! is_numeric($folderId)) {
            return null;
        }

        $folder = DocumentoArchivioCartella::query()
            ->where('stabile_id', $stabileId)
            ->whereKey((int) $folderId)
            ->first(['id']);

        return $folder ? (int) $folder->id : null;
    }

    private function resolveDefaultFolderIdForDocument(int $stabileId, string $categoria, int $year, mixed $folderId): ?int
    {
        $resolvedFolderId = $this->resolveFolderIdForDocument($stabileId, $folderId);
        if ($resolvedFolderId) {
            return $resolvedFolderId;
        }

        if ($categoria !== 'fattura') {
            return null;
        }

        $root = $this->ensureInvoiceRootFolder($stabileId);
        if (! $root instanceof DocumentoArchivioCartella) {
            return null;
        }

        return $this->ensureInvoiceYearFolder($stabileId, $root, $year)?->id;
    }

    private function normalizeStringArray(mixed $values): array
    {
        if (! is_array($values)) {
            return [];
        }

        return collect($values)
            ->map(fn($value): string => trim((string) $value))
            ->filter(fn(string $value): bool => $value !== '')
            ->unique()
            ->values()
            ->all();
    }

    private function normalizeIntArray(mixed $values): array
    {
        if (! is_array($values)) {
            return [];
        }

        return collect($values)
            ->filter(fn($value): bool => is_numeric($value) && (int) $value > 0)
            ->map(fn($value): int => (int) $value)
            ->unique()
            ->values()
            ->all();
    }

    private function normalizeNullableText(mixed $value): ?string
    {
        $value = trim((string) $value);

        return $value !== '' ? $value : null;
    }
}