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

use App\Models\CategoriaTicket;
use App\Models\Fornitore;
use App\Models\FornitoreDipendente;
use App\Models\Ticket;
use App\Models\TicketAttachment;
use App\Models\TicketIntervento;
use App\Models\User;
use App\Support\StabileContext;
use BackedEnum;
use Filament\Notifications\Notification;
use Filament\Pages\Page;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Schema;
use Illuminate\Support\Str;
use Illuminate\Validation\Rule;
use Livewire\WithFileUploads;
use UnitEnum;

class TicketGestione extends Page
{
    use WithFileUploads;

    protected static ?string $navigationLabel = 'Ticket Gestione';

    protected static ?string $title = 'Gestione Ticket';

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

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

    protected static ?int $navigationSort = 26;

    protected static ?string $slug = 'supporto/ticket-gestione';

    protected string $view = 'filament.pages.supporto.ticket-gestione';

    public string $status = 'open';

    public string $activeTab = 'elenco';

    public ?int $selectedTicketId = null;

    public ?string $notaInterna = null;

    public ?int $fornitoreId = null;

    public ?string $noteAssegnazione = null;

    /** @var array<int,mixed> */
    public array $nuoviAllegati = [];

    /** @var array<int,mixed> */
    public array $nuoveFoto = [];

    public ?string $descrizioneAllegati = null;

    public ?string $lastGeneratedPassword = null;

    public ?int $selectedCategoriaId = null;

    public ?string $categoriaNome = null;

    public ?string $categoriaDescrizione = null;

    /** @var array<int,array{id:int,nome:string,descrizione:string}> */
    public array $categorieOptions = [];

    /** @var array<int,array{id:int,nome:string}> */
    public array $fornitoriOptions = [];

    /** @var array<int,array<string,mixed>> */
    public array $fornitoriAttiviRows = [];

    /** @var array<string,mixed>|null */
    public ?array $attachmentPreview = null;

    /** @var \Illuminate\Support\Collection<int, Ticket> */
    public $tickets;

    /** @var array<string,int> */
    public array $ticketCounters = [
        'open'   => 0,
        'urgent' => 0,
        'closed' => 0,
        'all'    => 0,
    ];

    public static function canAccess(): bool
    {
        $user = Auth::user();

        return $user instanceof User
        && $user->hasAnyRole(['super-admin', 'admin', 'amministratore', 'collaboratore']);
    }

    public function mount(): void
    {
        $this->tickets = collect();

        $this->selectedTicketId = (int) request()->query('ticket', 0) ?: null;
        $queryTab               = (string) request()->query('tab', '');
        if ($queryTab === 'scheda') {
            $this->activeTab = 'scheda';
        }

        if (request()->query('status') === 'all') {
            $this->status = 'all';
        }

        $this->loadFornitoriOptions();
        $this->loadCategorieTicketOptions();
        $this->refreshFornitoriAttiviRows();
        if ($this->selectedTicket) {
            $this->fornitoreId = (int) ($this->selectedTicket->assegnato_a_fornitore_id ?? 0) ?: null;
        }

        $this->refreshData();
    }

    public function updatedSelectedCategoriaId($value): void
    {
        $id = (int) $value;
        if ($id <= 0) {
            $this->categoriaNome        = null;
            $this->categoriaDescrizione = null;
            return;
        }

        $categoria = CategoriaTicket::query()->find($id);
        if (! $categoria instanceof CategoriaTicket) {
            return;
        }

        $this->categoriaNome        = (string) $categoria->nome;
        $this->categoriaDescrizione = (string) ($categoria->descrizione ?? '');
    }

    public function creaCategoriaTicket(): void
    {
        $this->validate([
            'categoriaNome'        => ['required', 'string', 'max:255', Rule::unique('categorie_ticket', 'nome')],
            'categoriaDescrizione' => ['nullable', 'string', 'max:2000'],
        ]);

        $categoria = CategoriaTicket::query()->create([
            'nome'        => trim((string) $this->categoriaNome),
            'descrizione' => filled($this->categoriaDescrizione) ? trim((string) $this->categoriaDescrizione) : null,
        ]);

        $this->loadCategorieTicketOptions();
        $this->selectedCategoriaId = (int) $categoria->id;
        $this->updatedSelectedCategoriaId($this->selectedCategoriaId);

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

    public function aggiornaCategoriaTicket(): void
    {
        $id = (int) ($this->selectedCategoriaId ?? 0);
        if ($id <= 0) {
            Notification::make()->title('Seleziona una categoria da modificare')->warning()->send();
            return;
        }

        $this->validate([
            'categoriaNome'        => ['required', 'string', 'max:255', Rule::unique('categorie_ticket', 'nome')->ignore($id)],
            'categoriaDescrizione' => ['nullable', 'string', 'max:2000'],
        ]);

        $categoria = CategoriaTicket::query()->find($id);
        if (! $categoria instanceof CategoriaTicket) {
            Notification::make()->title('Categoria non trovata')->danger()->send();
            return;
        }

        $categoria->update([
            'nome'        => trim((string) $this->categoriaNome),
            'descrizione' => filled($this->categoriaDescrizione) ? trim((string) $this->categoriaDescrizione) : null,
        ]);

        $this->loadCategorieTicketOptions();
        Notification::make()->title('Categoria aggiornata')->success()->send();
        $this->refreshData();
    }

    public function updatedStatus(): void
    {
        $this->refreshData();
    }

    public function refreshData(): void
    {
        $this->loadCounters();
        $this->loadTickets();
        $this->refreshFornitoriAttiviRows();
    }

    public function getTicketInserimentoUrl(): string
    {
        return TicketMobile::getUrl(panel: 'admin-filament');
    }

    public function apriScheda(int $ticketId): void
    {
        $this->selectedTicketId = $ticketId;
        $this->activeTab        = 'scheda';

        $ticket            = $this->selectedTicket;
        $this->fornitoreId = $ticket ? ((int) ($ticket->assegnato_a_fornitore_id ?? 0) ?: null): null;
    }

    public function apriElenco(): void
    {
        $this->activeTab = 'elenco';
    }

    public function getFornitoreOperativoUrl(?int $fornitoreId = null): string
    {
        $base = route('fornitore.tickets.index');
        if ($fornitoreId) {
            return $base . '?fornitore=' . $fornitoreId;
        }

        return $base;
    }

    public function getFornitoreAnagraficaUrl(int $fornitoreId): string
    {
        return \App\Filament\Pages\Gescon\FornitoreScheda::getUrl(['record' => $fornitoreId], panel: 'admin-filament');
    }

    public function getAttachmentPublicUrl(TicketAttachment $attachment): string
    {
        return route('filament.tickets.attachments.view', ['attachment' => (int) $attachment->id]);
    }

    public function openAttachmentPreview(int $attachmentId): void
    {
        $ticket = $this->selectedTicket;
        if (! $ticket) {
            return;
        }

        $attachment = $ticket->attachments->firstWhere('id', $attachmentId);
        if (! $attachment instanceof TicketAttachment) {
            return;
        }

        $name = (string) ($attachment->original_file_name ?? 'allegato');
        $mime = strtolower((string) ($attachment->mime_type ?? ''));
        $ext  = strtolower((string) pathinfo($name, PATHINFO_EXTENSION));

        $isImage = str_starts_with($mime, 'image/') || in_array($ext, ['jpg', 'jpeg', 'png', 'webp', 'gif', 'bmp'], true);
        $isPdf   = $mime === 'application/pdf' || $ext === 'pdf';

        $this->attachmentPreview = [
            'id'          => (int) $attachment->id,
            'name'        => $name,
            'description' => (string) ($attachment->description ?? ''),
            'url'         => $this->getAttachmentPublicUrl($attachment),
            'is_image'    => $isImage,
            'is_pdf'      => $isPdf,
        ];
    }

    public function closeAttachmentPreview(): void
    {
        $this->attachmentPreview = null;
    }

    public function getSelectedTicketProperty(): ?Ticket
    {
        if (! $this->selectedTicketId) {
            return null;
        }

        $user = Auth::user();
        if (! $user instanceof User) {
            return null;
        }

        $stabileId = StabileContext::resolveActiveStabileId($user);
        if (! $stabileId) {
            return null;
        }

        return Ticket::query()
            ->with([
                'stabile:id,denominazione',
                'categoriaTicket:id,nome',
                'assegnatoAFornitore:id,ragione_sociale,nome,cognome',
                'attachments.user:id,name',
                'messages.user:id,name',
                'interventi.fornitore:id,ragione_sociale,nome,cognome',
                'interventi.creatoDaUser:id,name',
            ])
            ->where('stabile_id', $stabileId)
            ->find($this->selectedTicketId);
    }

    public function assegnaFornitore(): void
    {
        $ticket = $this->selectedTicket;
        if (! $ticket) {
            Notification::make()->title('Ticket non trovato')->danger()->send();
            return;
        }

        $this->validate([
            'fornitoreId'      => ['required', 'integer', 'exists:fornitori,id'],
            'noteAssegnazione' => ['nullable', 'string', 'max:4000'],
        ]);

        $ticket->update([
            'assegnato_a_fornitore_id' => $this->fornitoreId,
            'stato'                    => in_array($ticket->stato, ['Aperto'], true) ? 'Preso in Carico' : $ticket->stato,
        ]);

        if (Schema::hasTable('ticket_interventi')) {
            $ultimo = TicketIntervento::query()
                ->where('ticket_id', $ticket->id)
                ->where('fornitore_id', $this->fornitoreId)
                ->latest('id')
                ->first();

            if (! $ultimo) {
                TicketIntervento::query()->create([
                    'ticket_id'           => $ticket->id,
                    'fornitore_id'        => $this->fornitoreId,
                    'creato_da_user_id'   => Auth::id(),
                    'stato'               => 'assegnato',
                    'note_amministratore' => $this->noteAssegnazione,
                ]);
            }
        }

        if (filled($this->noteAssegnazione)) {
            $ticket->messages()->create([
                'user_id'   => Auth::id(),
                'messaggio' => 'Assegnazione fornitore: ' . trim((string) $this->noteAssegnazione),
            ]);
        }

        $this->noteAssegnazione = null;

        Notification::make()->title('Fornitore assegnato')->success()->send();
        $this->refreshData();
    }

    public function aggiungiNotaInterna(): void
    {
        $ticket = $this->selectedTicket;
        if (! $ticket) {
            Notification::make()->title('Ticket non trovato')->danger()->send();
            return;
        }

        $this->validate([
            'notaInterna' => ['required', 'string', 'max:5000'],
        ]);

        $stamp = now()->format('d/m/Y H:i');
        $ticket->messages()->create([
            'user_id'   => Auth::id(),
            'messaggio' => '[' . $stamp . '] ' . trim((string) $this->notaInterna),
        ]);

        $this->notaInterna = null;

        // Force refresh of selected ticket relations so the new note is visible immediately.
        $this->refreshData();

        Notification::make()->title('Nota aggiunta')->success()->send();
    }

    public function caricaAllegati(): void
    {
        $ticket = $this->selectedTicket;
        if (! $ticket) {
            Notification::make()->title('Ticket non trovato')->danger()->send();
            return;
        }

        if (! Schema::hasTable('ticket_attachments')) {
            Notification::make()->title('Tabella allegati non pronta')->danger()->send();
            return;
        }

        $this->validate([
            'nuoviAllegati'       => ['nullable', 'array', 'max:8'],
            'nuoviAllegati.*'     => ['file', 'max:10240', 'mimes:jpg,jpeg,png,webp,pdf,doc,docx,xls,xlsx,txt'],
            'nuoveFoto'           => ['nullable', 'array', 'max:8'],
            'nuoveFoto.*'         => ['file', 'max:10240', 'mimes:jpg,jpeg,png,webp'],
            'descrizioneAllegati' => ['nullable', 'string', 'max:500'],
        ]);

        $files = array_merge($this->nuoveFoto, $this->nuoviAllegati);
        if (count($files) === 0) {
            Notification::make()->title('Seleziona almeno un file o una foto')->warning()->send();
            return;
        }

        $saved = 0;
        foreach ($files as $file) {
            if (! is_object($file) || ! method_exists($file, 'store')) {
                continue;
            }

            $path = $file->store('ticket-gestione/' . $ticket->id, 'public');

            TicketAttachment::query()->create([
                'ticket_id'          => $ticket->id,
                'ticket_update_id'   => null,
                'user_id'            => Auth::id(),
                'file_path'          => $path,
                'original_file_name' => (string) $file->getClientOriginalName(),
                'mime_type'          => (string) $file->getClientMimeType(),
                'size'               => (int) $file->getSize(),
                'description'        => $this->descrizioneAllegati ?: 'Allegato da gestione ticket',
            ]);

            $saved++;
        }

        $this->nuoveFoto           = [];
        $this->nuoviAllegati       = [];
        $this->descrizioneAllegati = null;
        $this->refreshData();

        Notification::make()
            ->title('Allegati caricati')
            ->body('Caricati ' . $saved . ' allegati.')
            ->success()
            ->send();
    }

    public function prendiInCarico(int $ticketId): void
    {
        $this->aggiornaStatoTicket($ticketId, 'Preso in Carico', true);
    }

    public function avviaLavorazione(int $ticketId): void
    {
        $this->aggiornaStatoTicket($ticketId, 'In Lavorazione');
    }

    public function risolviTicket(int $ticketId): void
    {
        $this->aggiornaStatoTicket($ticketId, 'Risolto');
    }

    public function chiudiTicket(int $ticketId): void
    {
        $this->aggiornaStatoTicket($ticketId, 'Chiuso');
    }

    public function abilitaAccessoFornitoreDaTicket(int $fornitoreId): void
    {
        $user = Auth::user();
        if (! $user instanceof User) {
            return;
        }

        $stabileId = StabileContext::resolveActiveStabileId($user);
        if (! $stabileId) {
            Notification::make()->title('Stabile attivo non disponibile')->warning()->send();
            return;
        }

        $stabile = \App\Models\Stabile::query()->find($stabileId);
        $adminId = (int) ($stabile->amministratore_id ?? 0);

        $fornitore = Fornitore::query()->find($fornitoreId);
        if (! $fornitore instanceof Fornitore) {
            Notification::make()->title('Fornitore non trovato')->danger()->send();
            return;
        }

        if ($adminId > 0 && (int) ($fornitore->amministratore_id ?? 0) > 0 && (int) ($fornitore->amministratore_id ?? 0) !== $adminId) {
            Notification::make()->title('Fornitore non valido per questo stabile')->danger()->send();
            return;
        }

        $email = trim((string) ($fornitore->email ?? ''));
        if ($email === '') {
            Notification::make()->title('Email fornitore mancante')->warning()->send();
            return;
        }

        $dipendente = FornitoreDipendente::query()
            ->where('fornitore_id', (int) $fornitore->id)
            ->whereRaw('LOWER(email) = ?', [mb_strtolower($email)])
            ->first();

        if (! $dipendente instanceof FornitoreDipendente) {
            $dipendente = FornitoreDipendente::query()->create([
                'fornitore_id'       => (int) $fornitore->id,
                'nome'               => (string) ($fornitore->ragione_sociale ?: ($fornitore->nome ?: 'Referente fornitore')),
                'cognome'            => $fornitore->ragione_sociale ? null : (($fornitore->cognome ?? null) ?: null),
                'email'              => $email,
                'telefono'           => $fornitore->telefono ?: $fornitore->cellulare,
                'attivo'             => true,
                'created_by_user_id' => Auth::id(),
                'updated_by_user_id' => Auth::id(),
            ]);
        }

        $this->abilitaAccessoDipendente($dipendente);
        $this->refreshData();
    }

    public function resetPasswordFornitoreUser(int $userId): void
    {
        $user = Auth::user();
        if (! $user instanceof User) {
            return;
        }

        $stabileId = StabileContext::resolveActiveStabileId($user);
        if (! $stabileId) {
            Notification::make()->title('Stabile attivo non disponibile')->warning()->send();
            return;
        }

        $stabile = \App\Models\Stabile::query()->find($stabileId);
        $adminId = (int) ($stabile->amministratore_id ?? 0);

        $canReset = FornitoreDipendente::query()
            ->where('user_id', $userId)
            ->whereHas('fornitore', function ($q) use ($adminId): void {
                if ($adminId > 0) {
                    $q->where('amministratore_id', $adminId);
                }
            })
            ->exists();

        if (! $canReset) {
            Notification::make()->title('Utente non autorizzato per reset')->danger()->send();
            return;
        }

        $target = User::query()->find($userId);
        if (! $target instanceof User) {
            Notification::make()->title('Utente non trovato')->danger()->send();
            return;
        }

        $newPassword      = Str::random(12);
        $target->password = Hash::make($newPassword);
        $target->save();

        $this->lastGeneratedPassword = $newPassword;

        Notification::make()
            ->title('Password fornitore resettata')
            ->body('Nuova password temporanea: ' . $newPassword)
            ->success()
            ->send();
    }

    private function loadTickets(): void
    {
        $user = Auth::user();
        if (! $user instanceof User) {
            $this->tickets = collect();
            return;
        }

        $stabileId = StabileContext::resolveActiveStabileId($user);
        if (! $stabileId) {
            $this->tickets = collect();
            return;
        }

        $query = Ticket::query()
            ->with(['categoriaTicket', 'assegnatoAFornitore:id,ragione_sociale,nome,cognome', 'assegnatoAUser:id,name'])
            ->withCount('attachments')
            ->where('stabile_id', $stabileId);

        if ($this->status === 'open') {
            $query->whereIn('stato', ['Aperto', 'Preso in Carico', 'In Lavorazione']);
        } elseif ($this->status === 'urgent') {
            $query->where('priorita', 'Urgente')
                ->whereIn('stato', ['Aperto', 'Preso in Carico', 'In Lavorazione']);
        } elseif ($this->status === 'closed') {
            $query->whereIn('stato', ['Risolto', 'Chiuso']);
        }

        $this->tickets = $query->latest('data_apertura')->limit(50)->get();
    }

    private function refreshFornitoriAttiviRows(): void
    {
        $user = Auth::user();
        if (! $user instanceof User) {
            $this->fornitoriAttiviRows = [];
            return;
        }

        $stabileId = StabileContext::resolveActiveStabileId($user);
        if (! $stabileId) {
            $this->fornitoriAttiviRows = [];
            return;
        }

        $ticketApertiStati = ['Aperto', 'Preso in Carico', 'In Lavorazione', 'In Attesa Approvazione', 'In Attesa Ricambi'];

        $assignedTickets = Ticket::query()
            ->where('stabile_id', $stabileId)
            ->whereIn('stato', $ticketApertiStati)
            ->whereNotNull('assegnato_a_fornitore_id')
            ->get(['id', 'assegnato_a_fornitore_id', 'stato', 'updated_at']);

        $assignedByFornitore = $assignedTickets
            ->groupBy('assegnato_a_fornitore_id')
            ->map(fn($rows) => $rows->count());

        $ticketSummaries = $assignedTickets
            ->groupBy('assegnato_a_fornitore_id')
            ->map(function ($rows) {
                return $rows->sortByDesc('updated_at')->take(6)->map(function ($ticket): string {
                    return '#' . ((int) $ticket->id) . ' (' . (string) $ticket->stato . ')';
                })->values()->all();
            });

        $openInterventiByFornitore   = collect();
        $interventoStatiByFornitore  = collect();
        $lastInterventoAtByFornitore = collect();
        if (Schema::hasTable('ticket_interventi')) {
            $openInterventi = TicketIntervento::query()
                ->whereIn('stato', ['assegnato', 'in_corso', 'in_verifica'])
                ->whereHas('ticket', function ($q) use ($stabileId, $ticketApertiStati): void {
                    $q->where('stabile_id', $stabileId)->whereIn('stato', $ticketApertiStati);
                })
                ->orderByDesc('updated_at')
                ->get(['fornitore_id', 'stato', 'updated_at']);

            $openInterventiByFornitore = $openInterventi
                ->groupBy('fornitore_id')
                ->map(fn($rows) => $rows->count());

            $interventoStatiByFornitore = $openInterventi
                ->groupBy('fornitore_id')
                ->map(function ($rows): string {
                    return $rows->pluck('stato')
                        ->map(fn($stato) => str_replace('_', ' ', (string) $stato))
                        ->unique()
                        ->take(3)
                        ->implode(', ');
                });

            $lastInterventoAtByFornitore = $openInterventi
                ->groupBy('fornitore_id')
                ->map(function ($rows): ?string {
                    $last = $rows->sortByDesc('updated_at')->first();
                    return $last && $last->updated_at ? $last->updated_at->format('d/m/Y H:i') : null;
                });
        }

        $fornitoriIds = collect($assignedByFornitore->keys())
            ->merge($openInterventiByFornitore->keys())
            ->map(fn($v) => (int) $v)
            ->filter(fn(int $v) => $v > 0)
            ->unique()
            ->values();

        if ($fornitoriIds->isEmpty()) {
            $this->fornitoriAttiviRows = [];
            return;
        }

        $rows       = [];
        $accessRows = FornitoreDipendente::query()
            ->whereIn('fornitore_id', $fornitoriIds->all())
            ->get(['fornitore_id', 'user_id']);

        $dipCountByFornitore = $accessRows
            ->groupBy('fornitore_id')
            ->map(fn($r) => $r->count());

        $linkedUserByFornitore = $accessRows
            ->filter(fn($r) => (int) ($r->user_id ?? 0) > 0)
            ->groupBy('fornitore_id')
            ->map(fn($r) => (int) ($r->first()->user_id ?? 0));

        foreach (Fornitore::query()->whereIn('id', $fornitoriIds->all())->orderBy('ragione_sociale')->orderBy('cognome')->orderBy('nome')->get() as $fornitore) {
            $rows[] = [
                'id'                   => (int) $fornitore->id,
                'nome'                 => trim((string) ($fornitore->ragione_sociale ?: trim(($fornitore->nome ?? '') . ' ' . ($fornitore->cognome ?? '')))),
                'email'                => (string) ($fornitore->email ?? ''),
                'telefono'             => (string) ($fornitore->telefono ?: $fornitore->cellulare),
                'ticket_attivi'        => (int) ($assignedByFornitore->get((string) $fornitore->id) ?? $assignedByFornitore->get((int) $fornitore->id) ?? 0),
                'interventi_aperti'    => (int) ($openInterventiByFornitore->get((string) $fornitore->id) ?? $openInterventiByFornitore->get((int) $fornitore->id) ?? 0),
                'ticket_focus'         => (array) ($ticketSummaries->get((string) $fornitore->id) ?? $ticketSummaries->get((int) $fornitore->id) ?? []),
                'intervento_stati'     => (string) ($interventoStatiByFornitore->get((string) $fornitore->id) ?? $interventoStatiByFornitore->get((int) $fornitore->id) ?? ''),
                'ultimo_aggiornamento' => (string) ($lastInterventoAtByFornitore->get((string) $fornitore->id) ?? $lastInterventoAtByFornitore->get((int) $fornitore->id) ?? ''),
                'dipendenti_count'     => (int) ($dipCountByFornitore->get((string) $fornitore->id) ?? $dipCountByFornitore->get((int) $fornitore->id) ?? 0),
                'linked_user_id'       => (int) ($linkedUserByFornitore->get((string) $fornitore->id) ?? $linkedUserByFornitore->get((int) $fornitore->id) ?? 0),
            ];
        }

        usort($rows, function (array $a, array $b): int {
            $lhs = ((int) $a['interventi_aperti']) * 1000 + (int) $a['ticket_attivi'];
            $rhs = ((int) $b['interventi_aperti']) * 1000 + (int) $b['ticket_attivi'];
            return $rhs <=> $lhs;
        });

        $this->fornitoriAttiviRows = $rows;
    }

    private function abilitaAccessoDipendente(FornitoreDipendente $dipendente): void
    {
        $email = trim((string) ($dipendente->email ?? ''));
        if ($email === '') {
            Notification::make()->title('Email dipendente mancante')->warning()->send();
            return;
        }

        $existingUser = User::query()->whereRaw('LOWER(email) = ?', [mb_strtolower($email)])->first();
        $created      = false;
        if (! $existingUser instanceof User) {
            $generatedPassword = Str::random(12);
            $existingUser      = User::query()->create([
                'name'              => trim((string) ($dipendente->nome_completo ?: 'Utente fornitore')),
                'email'             => $email,
                'password'          => Hash::make($generatedPassword),
                'email_verified_at' => now(),
                'is_active'         => true,
            ]);

            $this->lastGeneratedPassword = $generatedPassword;
            $created                     = true;
        }

        $existingUser->assignRole('fornitore');

        $dipendente->user_id            = (int) $existingUser->id;
        $dipendente->updated_by_user_id = Auth::id();
        $dipendente->save();

        $body = $created
            ? 'Accesso creato. Password temporanea: ' . ($this->lastGeneratedPassword ?? '(non disponibile)')
            : 'Accesso attivato/aggiornato per utente esistente.';

        Notification::make()->title('Accesso fornitore abilitato')->body($body)->success()->send();
    }

    private function loadFornitoriOptions(): void
    {
        $user = Auth::user();
        if (! $user instanceof User) {
            $this->fornitoriOptions = [];
            return;
        }

        $stabileId = StabileContext::resolveActiveStabileId($user);
        if (! $stabileId) {
            $this->fornitoriOptions = [];
            return;
        }

        $stabile = \App\Models\Stabile::query()->find($stabileId);
        $adminId = (int) ($stabile->amministratore_id ?? 0);

        $query = Fornitore::query()->orderBy('ragione_sociale')->orderBy('cognome')->orderBy('nome');
        if ($adminId > 0) {
            $query->where(function ($q) use ($adminId): void {
                $q->where('amministratore_id', $adminId)->orWhereNull('amministratore_id');
            });
        }

        $this->fornitoriOptions = $query->limit(400)->get()->map(function (Fornitore $f): array {
            $label = trim((string) ($f->ragione_sociale ?: trim(($f->nome ?? '') . ' ' . ($f->cognome ?? ''))));
            return [
                'id'   => (int) $f->id,
                'nome' => $label !== '' ? $label : ('Fornitore #' . $f->id),
            ];
        })->all();
    }

    private function loadCategorieTicketOptions(): void
    {
        if (! Schema::hasTable('categorie_ticket')) {
            $this->categorieOptions = [];
            return;
        }

        $this->categorieOptions = CategoriaTicket::query()
            ->orderBy('nome')
            ->get(['id', 'nome', 'descrizione'])
            ->map(fn(CategoriaTicket $c): array=> [
                'id'          => (int) $c->id,
                'nome'        => (string) $c->nome,
                'descrizione' => (string) ($c->descrizione ?? ''),
            ])
            ->all();
    }

    public function getTipoInterventoLabel(Ticket $ticket): string
    {
        $categoria = trim((string) optional($ticket->categoriaTicket)->nome);
        $titolo    = trim((string) ($ticket->titolo ?? ''));

        if ($categoria !== '' && $titolo !== '') {
            return $categoria . ' - ' . $titolo;
        }

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

        if ($titolo !== '') {
            return $titolo;
        }

        return 'N/D';
    }

    private function loadCounters(): void
    {
        $user = Auth::user();
        if (! $user instanceof User) {
            $this->ticketCounters = ['open' => 0, 'urgent' => 0, 'closed' => 0, 'all' => 0];
            return;
        }

        $stabileId = StabileContext::resolveActiveStabileId($user);
        if (! $stabileId) {
            $this->ticketCounters = ['open' => 0, 'urgent' => 0, 'closed' => 0, 'all' => 0];
            return;
        }

        $base = Ticket::query()->where('stabile_id', $stabileId);

        $this->ticketCounters = [
            'open'   => (clone $base)->whereIn('stato', ['Aperto', 'Preso in Carico', 'In Lavorazione'])->count(),
            'urgent' => (clone $base)->where('priorita', 'Urgente')->whereIn('stato', ['Aperto', 'Preso in Carico', 'In Lavorazione'])->count(),
            'closed' => (clone $base)->whereIn('stato', ['Risolto', 'Chiuso'])->count(),
            'all'    => (clone $base)->count(),
        ];
    }

    private function aggiornaStatoTicket(int $ticketId, string $nuovoStato, bool $assegnaAUtente = false): void
    {
        $user = Auth::user();
        if (! $user instanceof User) {
            return;
        }

        $stabileId = StabileContext::resolveActiveStabileId($user);
        if (! $stabileId) {
            return;
        }

        $ticket = Ticket::query()
            ->where('id', $ticketId)
            ->where('stabile_id', $stabileId)
            ->first();

        if (! $ticket) {
            Notification::make()
                ->title('Ticket non trovato o non accessibile')
                ->danger()
                ->send();
            return;
        }

        $payload = ['stato' => $nuovoStato];
        if ($assegnaAUtente) {
            $payload['assegnato_a_user_id'] = $user->id;
        }
        if ($nuovoStato === 'Risolto' && ! $ticket->data_risoluzione_effettiva) {
            $payload['data_risoluzione_effettiva'] = now()->toDateString();
        }
        if ($nuovoStato === 'Chiuso' && ! $ticket->data_chiusura_effettiva) {
            $payload['data_chiusura_effettiva'] = now()->toDateString();
        }

        $ticket->update($payload);

        Notification::make()
            ->title('Ticket #' . $ticket->id . ' aggiornato a ' . $nuovoStato)
            ->success()
            ->send();

        $this->refreshData();
    }
}