<?php

namespace App\Livewire\Settings;

use App\Jobs\ImportTerritoryPdfFolder;
use App\Models\AnnoTeocratico;
use App\Models\Assegnazione;
use App\Models\Campagna;
use App\Models\Proclamatore;
use App\Models\Setting;
use App\Models\Territorio;
use App\Models\Tipologia;
use App\Models\User;
use App\Models\Zona;
use App\Services\TerritorioPdfImportDispatcher;
use App\Services\TerritorioPdfImportState;
use Barryvdh\DomPDF\Facade\Pdf;
use Carbon\Carbon;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Str;
use Livewire\Component;
use Livewire\WithFileUploads;

class XmlExchange extends Component
{
    use WithFileUploads;

    public array $importStats = [];
    public array $importIssues = [];
    public array $pdfFolder = [];
    public array $pdfImportLogs = [];
    public array $pdfImportStats = [];
    public array $pdfImportIssues = [];
    public ?string $currentPdfImportId = null;
    public string $pdfImportStatus = 'idle';
    public string $pdfImportLogText = '';

    public function mount(): void
    {
        $this->currentPdfImportId = request()->query('pdf-import');

        if ($this->currentPdfImportId) {
            $this->refreshPdfImportStatus();
        }
    }

    public function importTerritoryPdfFolder(): void
    {
        $this->validate([
            'pdfFolder' => ['required', 'array', 'min:1'],
            'pdfFolder.*' => ['file', 'mimes:pdf', 'max:10240'],
        ]);

        $importId = (string) Str::uuid();
        $storedFiles = [];

        foreach ($this->pdfFolder as $index => $file) {
            $originalName = $file->getClientOriginalName();
            $safeName = Str::slug(pathinfo($originalName, PATHINFO_FILENAME));
            $extension = strtolower($file->getClientOriginalExtension() ?: 'pdf');
            $storedPath = $file->storeAs(
                'bulk-territori-imports/' . $importId,
                str_pad((string) $index, 4, '0', STR_PAD_LEFT) . '-' . $safeName . '.' . $extension,
                'local'
            );

            $storedFiles[] = [
                'original_name' => $originalName,
                'stored_path' => $storedPath,
            ];
        }

        $this->pdfFolder = [];

        $this->dispatchPdfImport(
            $importId,
            $storedFiles,
            'Cartella ricevuta: ' . count($storedFiles) . ' PDF in coda.'
        );
    }

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

        $state = app(TerritorioPdfImportState::class)->get($this->currentPdfImportId);

        if (! $state) {
            return;
        }

        $this->pdfImportStatus = $state['status'] ?? 'idle';
        $this->pdfImportStats = $state['stats'] ?? [];
        $this->pdfImportLogs = $state['logs'] ?? [];
        $this->pdfImportIssues = $state['issues'] ?? [];
        $this->pdfImportLogText = implode(PHP_EOL, $this->pdfImportLogs);
    }

    protected function dispatchPdfImport(string $importId, array $storedFiles, string $initialLog): void
    {
        $state = app(TerritorioPdfImportDispatcher::class)
            ->dispatchStoredFiles($importId, $storedFiles, auth()->id(), $initialLog);

        $this->currentPdfImportId = $importId;
        $this->pdfImportStatus = $state['status'] ?? 'queued';
        $this->pdfImportStats = $state['stats'] ?? [];
        $this->pdfImportLogs = $state['logs'] ?? [];
        $this->pdfImportIssues = $state['issues'] ?? [];
        $this->refreshPdfImportStatus();

        session()->flash('success', 'Import PDF avviato in background. I log si aggiorneranno automaticamente.');
    }

    public function downloadImportLogPdf()
    {
        if (empty($this->importStats)) {
            session()->flash('error', 'Nessun log da scaricare. Esegui prima un import XML.');
            return;
        }

        $stats = $this->importStats;
        $issues = $this->importIssues;
        $generatedAt = now()->format('d/m/Y H:i:s');

        $html = view('pdf.import-log', compact('stats', 'issues', 'generatedAt'))->render();

        return response()->streamDownload(function () use ($html) {
            echo Pdf::loadHTML($html)
                ->setPaper('a4', 'portrait')
                ->output();
        }, 'import-log-' . now()->format('Ymd-His') . '.pdf', ['Content-Type' => 'application/pdf']);
    }

    public function exportCurrentAsXml()
    {
        $dataset = $this->currentDataset();
        $xml = $this->datasetToXml($dataset, 'current-app-export');

        return response()->streamDownload(function () use ($xml) {
            echo $xml;
        }, 'termanager-export.xml', ['Content-Type' => 'application/xml; charset=UTF-8']);
    }

    public function render()
    {
        if (session()->has('importStats')) {
            $this->importStats = session('importStats');
        }
        if (session()->has('importIssues')) {
            $this->importIssues = session('importIssues');
        }

        return view('livewire.settings.xml-exchange');
    }

    public function legacySqlToDatasetPublic(string $sql): array
    {
        return $this->legacySqlToDataset($sql);
    }

    public function datasetToXmlPublic(array $dataset, string $source): string
    {
        return $this->datasetToXml($dataset, $source);
    }

    public function importXmlFromContent(string $content): array
    {
        $this->importStats = [];
        $this->importIssues = [];

        $xml = @simplexml_load_string($content);
        if (! $xml) {
            return ['error' => 'Impossibile leggere il file XML.'];
        }

        $actorId = auth()->id() ?? User::query()->value('id');
        if (! $actorId) {
            return ['error' => 'Serve almeno un utente nel sistema per importare i dati.'];
        }

        $stats = [
            'utenti_importati' => 0,
            'zone_importate' => 0,
            'tipologie_importate' => 0,
            'proclamatori_importati' => 0,
            'anni_importati' => 0,
            'campagne_importate' => 0,
            'territori_importati' => 0,
            'assegnazioni_importate' => 0,
            'duplicate_territori' => 0,
            'assegnazioni_saltate' => 0,
        ];

        DB::transaction(function () use ($xml, $actorId, &$stats) {
            Assegnazione::query()->delete();
            Campagna::query()->delete();
            Territorio::query()->withTrashed()->forceDelete();
            Proclamatore::query()->withTrashed()->forceDelete();
            Tipologia::query()->delete();
            Zona::query()->delete();
            AnnoTeocratico::query()->delete();
            Setting::query()->delete();

            // The mass delete above fires no model events, so Setting's
            // memoized instance still points at the deleted row. Without this
            // the update() below would target a nonexistent id, match zero
            // rows, and silently leave the app with no settings at all.
            Setting::flushCache();

            $settingsNode = $xml->settings;
            if ($settingsNode) {
                Setting::instance()->update([
                    'congregazione_nome' => (string) ($settingsNode->congregazione_nome ?? ''),
                    'public_base_url' => (string) ($settingsNode->public_base_url ?? ''),
                    'logo_path' => (string) ($settingsNode->logo_path ?? ''),
                    'giorni_giacenza_da_assegnare' => (int) ($settingsNode->giorni_giacenza_da_assegnare ?? 120),
                    'giorni_giacenza_prioritari' => (int) ($settingsNode->giorni_giacenza_prioritari ?? 180),
                    'giorni_per_smarrito' => (int) ($settingsNode->giorni_per_smarrito ?? 120),
                    'home_limit_list' => (int) ($settingsNode->home_limit_list ?? 10),
                    'assignment_link_ttl_hours' => (int) ($settingsNode->assignment_link_ttl_months ?? $settingsNode->assignment_link_ttl_hours ?? 1),
                    'pdf_viewer_show_download' => ((int) ($settingsNode->pdf_viewer_show_download ?? 0)) === 1,
                    'audit_retention_days' => (int) ($settingsNode->audit_retention_days ?? 730),
                    // The first-run wizard was removed; an imported dataset always
                    // represents a configured install, so setup is complete.
                    'setup_completed' => true,
                ]);
            }

            // Users are UPSERTED by email, never wiped. Deleting the users
            // table during a restore risks locking out the administrator
            // performing the import (e.g. a backup that predates their account,
            // or a partial file). Existing accounts are updated in place;
            // accounts in the file are (re)created. $userMap remaps the
            // created_by/returned_by FKs on the assignments below.
            $userMap = [];
            foreach (($xml->users->user ?? []) as $userNode) {
                $email = trim((string) ($userNode->email ?? ''));
                $legacyId = (string) ($userNode['legacy_id'] ?? '');

                if ($email === '') {
                    $this->pushImportIssue('utente', $legacyId, 'Email mancante');
                    continue;
                }

                $user = User::query()->firstOrNew(['email' => $email]);
                $user->name = (string) ($userNode->name ?? $email);
                if (! $user->exists) {
                    // password is NOT NULL; the real hash is written raw below.
                    $user->password = Str::password(24);
                }
                $user->save();

                // Ensure every referenced role exists before syncing — the
                // standard three come from the seeder, but a custom role in the
                // backup would otherwise make syncRoles() throw.
                $roleNames = [];
                foreach (($userNode->roles->role ?? []) as $roleNode) {
                    $roleName = trim((string) $roleNode);
                    if ($roleName !== '') {
                        \Spatie\Permission\Models\Role::firstOrCreate(['name' => $roleName, 'guard_name' => 'web']);
                        $roleNames[] = $roleName;
                    }
                }
                $user->syncRoles($roleNames);

                // Password hash, remember_token, verification flag and
                // timestamps are written with the query builder: the raw stored
                // hash is preserved exactly (the 'hashed' cast would re-validate
                // the bcrypt cost and could reject a hash made with a different
                // BCRYPT_ROUNDS), and Eloquent does not stamp its own timestamps.
                $meta = [];
                $passwordHash = (string) ($userNode->password ?? '');
                if ($passwordHash !== '') {
                    $meta['password'] = $passwordHash;
                }
                $rememberToken = (string) ($userNode->remember_token ?? '');
                $meta['remember_token'] = $rememberToken !== '' ? $rememberToken : null;
                $meta['email_verified_at'] = $this->normalizeDateTimeForDb((string) ($userNode->email_verified_at ?? ''));

                $createdAt = $this->normalizeDateTimeForDb((string) ($userNode->created_at ?? ''));
                if ($createdAt !== null) {
                    $meta['created_at'] = $createdAt;
                }
                $updatedAt = $this->normalizeDateTimeForDb((string) ($userNode->updated_at ?? ''));
                if ($updatedAt !== null) {
                    $meta['updated_at'] = $updatedAt;
                }

                DB::table('users')->where('id', $user->id)->update($meta);

                $stats['utenti_importati']++;
                if ($legacyId !== '') {
                    $userMap[$legacyId] = $user->id;
                }
            }

            $zoneMap = [];
            foreach (($xml->zones->zone ?? []) as $zoneNode) {
                $z = Zona::create([
                    'nome' => (string) $zoneNode->nome,
                    'attivo' => ((int) ($zoneNode->attivo ?? 1)) === 1,
                ]);
                $this->applyRowMeta('zone', $z->id, $zoneNode);
                $stats['zone_importate']++;
                $legacyId = (string) ($zoneNode['legacy_id'] ?? '');
                if ($legacyId !== '') {
                    $zoneMap[$legacyId] = $z->id;
                }
            }

            $tipologiaMap = [];
            foreach (($xml->tipologie->tipologia ?? []) as $tipologiaNode) {
                $t = Tipologia::create([
                    'nome' => (string) $tipologiaNode->nome,
                    'attivo' => ((int) ($tipologiaNode->attivo ?? 1)) === 1,
                ]);
                $this->applyRowMeta('tipologie', $t->id, $tipologiaNode);
                $stats['tipologie_importate']++;
                $legacyId = (string) ($tipologiaNode['legacy_id'] ?? '');
                if ($legacyId !== '') {
                    $tipologiaMap[$legacyId] = $t->id;
                }
            }

            $proclamatoreMap = [];
            foreach (($xml->proclamatori->proclamatore ?? []) as $proclamatoreNode) {
                $p = Proclamatore::create([
                    'nome' => (string) $proclamatoreNode->nome,
                    'cognome' => (string) $proclamatoreNode->cognome,
                    'attivo' => ((int) ($proclamatoreNode->attivo ?? 1)) === 1,
                ]);
                $this->applyRowMeta('proclamatori', $p->id, $proclamatoreNode, true);
                $stats['proclamatori_importati']++;
                $legacyId = (string) ($proclamatoreNode['legacy_id'] ?? '');
                if ($legacyId !== '') {
                    $proclamatoreMap[$legacyId] = $p->id;
                }
            }

            $annoMap = [];
            foreach (($xml->anni_teocratici->anno ?? []) as $annoNode) {
                $label = (string) $annoNode->label;
                $anno = AnnoTeocratico::create([
                    'label' => $label,
                    'start_date' => (string) $annoNode->start_date,
                    'end_date' => (string) $annoNode->end_date,
                ]);
                $this->applyRowMeta('anni_teocratici', $anno->id, $annoNode);
                $stats['anni_importati']++;
                $legacyId = (string) ($annoNode['legacy_id'] ?? '');
                if ($legacyId !== '') {
                    $annoMap[$legacyId] = $anno->id;
                }
            }

            $campagnaMap = [];
            foreach (($xml->campagne->campagna ?? []) as $campagnaNode) {
                $campagna = Campagna::create([
                    'descrizione' => (string) $campagnaNode->descrizione,
                    'start_date' => (string) $campagnaNode->start_date,
                    'end_date' => (string) $campagnaNode->end_date,
                ]);
                $this->applyRowMeta('campagne', $campagna->id, $campagnaNode);
                $stats['campagne_importate']++;
                $legacyId = (string) ($campagnaNode['legacy_id'] ?? '');
                if ($legacyId !== '') {
                    $campagnaMap[$legacyId] = $campagna->id;
                }
            }

            $territorioMap = [];
            $territoriNumeroVisti = [];
            foreach (($xml->territori->territorio ?? []) as $territorioNode) {
                $legacyZonaId = (string) ($territorioNode->legacy_zona_id ?? '');
                $legacyTipologiaId = (string) ($territorioNode->legacy_tipologia_id ?? '');
                $numero = trim((string) $territorioNode->numero);
                $legacyId = (string) ($territorioNode['legacy_id'] ?? '');

                if ($numero === '' || isset($territoriNumeroVisti[$numero])) {
                    $stats['duplicate_territori']++;
                    $this->pushImportIssue('territorio', $legacyId, 'Territorio duplicato o numero vuoto (numero=' . ($numero !== '' ? $numero : 'vuoto') . ')');
                    continue;
                }

                if (!isset($zoneMap[$legacyZonaId], $tipologiaMap[$legacyTipologiaId])) {
                    $this->pushImportIssue('territorio', $legacyId, 'Riferimento zona/tipologia non trovato (zona=' . $legacyZonaId . ', tipologia=' . $legacyTipologiaId . ')');
                    continue;
                }

                $pdfPath = (string) ($territorioNode->pdf_path ?? '');
                $thumbnailPath = (string) ($territorioNode->thumbnail_path ?? '');

                $territorio = Territorio::create([
                    'numero' => $numero,
                    'zona_id' => $zoneMap[$legacyZonaId],
                    'tipologia_id' => $tipologiaMap[$legacyTipologiaId],
                    'confini' => (string) ($territorioNode->confini ?? ''),
                    'note' => (string) ($territorioNode->note ?? ''),
                    'attivo' => ((int) ($territorioNode->attivo ?? 1)) === 1,
                    'prioritario' => ((int) ($territorioNode->prioritario ?? 0)) === 1,
                    'pdf_path' => $pdfPath !== '' ? $pdfPath : null,
                    'thumbnail_path' => $thumbnailPath !== '' ? $thumbnailPath : null,
                ]);
                $this->applyRowMeta('territori', $territorio->id, $territorioNode, true);

                $territoriNumeroVisti[$numero] = true;
                $stats['territori_importati']++;

                if ($legacyId !== '') {
                    $territorioMap[$legacyId] = $territorio->id;
                }
            }

            foreach (($xml->assegnazioni->assegnazione ?? []) as $assegnazioneNode) {
                $legacyTerritorio = (string) ($assegnazioneNode->legacy_territorio_id ?? '');
                $legacyProclamatore = (string) ($assegnazioneNode->legacy_proclamatore_id ?? '');
                $legacyAnno = (string) ($assegnazioneNode->legacy_anno_id ?? '');
                $legacyId = (string) ($assegnazioneNode['legacy_id'] ?? '');
                $assignedAt = $this->normalizeDateForDb((string) ($assegnazioneNode->assigned_at ?? ''), false);
                $returnedAt = $this->normalizeDateForDb((string) ($assegnazioneNode->returned_at ?? ''), true);

                if (!isset($territorioMap[$legacyTerritorio], $proclamatoreMap[$legacyProclamatore], $annoMap[$legacyAnno])) {
                    $stats['assegnazioni_saltate']++;
                    $this->pushImportIssue('assegnazione', $legacyId, 'Riferimenti mancanti (territorio=' . $legacyTerritorio . ', proclamatore=' . $legacyProclamatore . ', anno=' . $legacyAnno . ')');
                    continue;
                }

                if ($assignedAt === null) {
                    $stats['assegnazioni_saltate']++;
                    $this->pushImportIssue('assegnazione', $legacyId, 'Data assigned_at non valida o vuota');
                    continue;
                }

                $legacyCampagna = (string) ($assegnazioneNode->legacy_campagna_id ?? '');

                // Remap the audit FKs onto the imported users; fall back to the
                // acting user when the referenced account isn't in the file.
                $legacyCreatedBy = (string) ($assegnazioneNode->legacy_created_by_id ?? '');
                $createdBy = ($legacyCreatedBy !== '' && isset($userMap[$legacyCreatedBy]))
                    ? $userMap[$legacyCreatedBy]
                    : $actorId;

                $returnedBy = null;
                if ($returnedAt !== null) {
                    $legacyReturnedBy = (string) ($assegnazioneNode->legacy_returned_by_id ?? '');
                    $returnedBy = ($legacyReturnedBy !== '' && isset($userMap[$legacyReturnedBy]))
                        ? $userMap[$legacyReturnedBy]
                        : $actorId;
                }

                $pdfAccessCode = (string) ($assegnazioneNode->pdf_access_code ?? '');

                $assegnazione = Assegnazione::create([
                    'territorio_id' => $territorioMap[$legacyTerritorio],
                    'proclamatore_id' => $proclamatoreMap[$legacyProclamatore],
                    'anno_teocratico_id' => $annoMap[$legacyAnno],
                    'assigned_at' => $assignedAt,
                    'returned_at' => $returnedAt,
                    'counted_in_campaign' => ((int) ($assegnazioneNode->counted_in_campaign ?? 0)) === 1,
                    'campaign_id' => $legacyCampagna !== '' && isset($campagnaMap[$legacyCampagna]) ? $campagnaMap[$legacyCampagna] : null,
                    'link_sent' => ((int) ($assegnazioneNode->link_sent ?? 0)) === 1,
                    'pdf_access_code' => $pdfAccessCode !== '' ? $pdfAccessCode : null,
                    'note' => (string) ($assegnazioneNode->note ?? ''),
                    'created_by' => $createdBy,
                    'returned_by' => $returnedBy,
                ]);
                $this->applyRowMeta('assegnazioni', $assegnazione->id, $assegnazioneNode);
                $stats['assegnazioni_importate']++;
            }
        });

        return [
            'stats' => $stats,
            'issues' => $this->importIssues,
        ];
    }

    private function currentDataset(): array
    {
        $settings = Setting::instance();

        return [
            'settings' => [
                'congregazione_nome' => (string) ($settings->congregazione_nome ?? ''),
                'public_base_url' => (string) ($settings->public_base_url ?? ''),
                'logo_path' => (string) ($settings->logo_path ?? ''),
                'giorni_giacenza_da_assegnare' => (int) ($settings->giorni_giacenza_da_assegnare ?? 120),
                'giorni_giacenza_prioritari' => (int) ($settings->giorni_giacenza_prioritari ?? 180),
                'giorni_per_smarrito' => (int) ($settings->giorni_per_smarrito ?? 120),
                'home_limit_list' => (int) ($settings->home_limit_list ?? 10),
                'assignment_link_ttl_months' => (int) ($settings->assignment_link_ttl_hours ?? 1),
                'pdf_viewer_show_download' => (int) ((bool) ($settings->pdf_viewer_show_download ?? false)),
                'audit_retention_days' => (int) ($settings->audit_retention_days ?? 730),
                'setup_completed' => (int) ((bool) ($settings->setup_completed ?? true)),
            ],
            // Full user rows, credentials included. getAuthPassword() bypasses
            // the $hidden guard to read the raw bcrypt hash; roles come from the
            // Spatie relation. This is sensitive data — see the note in the
            // export UI / HANDOFF.
            'users' => User::query()->with('roles')->orderBy('id')->get()->map(fn ($u) => [
                'legacy_id' => (string) $u->id,
                'name' => (string) $u->name,
                'email' => (string) $u->email,
                'password' => (string) $u->getAuthPassword(),
                'email_verified_at' => optional($u->email_verified_at)->toIso8601String() ?? '',
                'remember_token' => (string) ($u->getRememberToken() ?? ''),
                'roles' => $u->roles->pluck('name')->all(),
                'created_at' => optional($u->created_at)->toIso8601String() ?? '',
                'updated_at' => optional($u->updated_at)->toIso8601String() ?? '',
            ])->all(),
            'zones' => Zona::query()->orderBy('id')->get(['id', 'nome', 'attivo', 'created_at', 'updated_at'])->toArray(),
            'tipologie' => Tipologia::query()->orderBy('id')->get(['id', 'nome', 'attivo', 'created_at', 'updated_at'])->toArray(),
            'proclamatori' => Proclamatore::query()->withTrashed()->orderBy('id')->get(['id', 'nome', 'cognome', 'attivo', 'deleted_at', 'created_at', 'updated_at'])->toArray(),
            'territori' => Territorio::query()->withTrashed()->orderBy('id')->get(['id', 'numero', 'zona_id', 'tipologia_id', 'confini', 'note', 'attivo', 'prioritario', 'pdf_path', 'thumbnail_path', 'deleted_at', 'created_at', 'updated_at'])->toArray(),
            'anni_teocratici' => AnnoTeocratico::query()->orderBy('id')->get(['id', 'label', 'start_date', 'end_date', 'created_at', 'updated_at'])->toArray(),
            'campagne' => Campagna::query()->orderBy('id')->get(['id', 'descrizione', 'start_date', 'end_date', 'created_at', 'updated_at'])->toArray(),
            'assegnazioni' => Assegnazione::query()->orderBy('id')->get(['id', 'territorio_id', 'proclamatore_id', 'anno_teocratico_id', 'campaign_id', 'assigned_at', 'returned_at', 'counted_in_campaign', 'note', 'created_by', 'returned_by', 'link_sent', 'pdf_access_code', 'created_at', 'updated_at'])->toArray(),
        ];
    }

    private function legacySqlToDataset(string $sql): array
    {
        $rows = $this->extractInsertRows($sql);

        $congregazione = $rows['congregazione'][0][1] ?? 'Congregazione';
        $impostazioni = $rows['impostazioni'][0] ?? [1, 120, 10, 120];

        $settings = [
            'congregazione_nome' => (string) $congregazione,
            'giorni_giacenza_da_assegnare' => (int) ($impostazioni[3] ?? 120),
            'giorni_giacenza_prioritari' => (int) ($impostazioni[1] ?? 180),
            'giorni_per_smarrito' => (int) ($impostazioni[3] ?? 120),
            'home_limit_list' => (int) ($impostazioni[2] ?? 10),
            'assignment_link_ttl_months' => 1,
            'audit_retention_days' => 730,
        ];

        $zones = [];
        foreach (($rows['zona'] ?? []) as $r) {
            $zones[] = [
                'legacy_id' => (string) ($r[0] ?? ''),
                'nome' => (string) ($r[1] ?? ''),
                'attivo' => 1,
            ];
        }

        $tipologie = [];
        foreach (($rows['tipologia'] ?? []) as $r) {
            $tipologie[] = [
                'legacy_id' => (string) ($r[0] ?? ''),
                'nome' => (string) ($r[1] ?? ''),
                'attivo' => 1,
            ];
        }

        $proclamatori = [];
        foreach (($rows['proclamatore'] ?? []) as $r) {
            $proclamatori[] = [
                'legacy_id' => (string) ($r[0] ?? ''),
                'cognome' => (string) ($r[1] ?? ''),
                'nome' => (string) ($r[2] ?? ''),
                'attivo' => ((int) ($r[3] ?? 1)) === 1 ? 1 : 0,
            ];
        }

        $territori = [];
        foreach (($rows['territorio'] ?? []) as $r) {
            $territori[] = [
                'legacy_id' => (string) ($r[0] ?? ''),
                'numero' => (string) ($r[1] ?? ''),
                'legacy_tipologia_id' => (string) ($r[2] ?? ''),
                'legacy_zona_id' => (string) ($r[3] ?? ''),
                'confini' => (string) ($r[4] ?? ''),
                'note' => (string) ($r[5] ?? ''),
                'attivo' => ((int) ($r[8] ?? 1)) === 1 ? 1 : 0,
                'prioritario' => ((int) ($r[11] ?? 0)) > 0 ? 1 : 0,
            ];
        }

        $anni = [];
        foreach (($rows['annoServizio'] ?? []) as $r) {
            $label = (string) ($r[1] ?? '');
            [$startDate, $endDate] = $this->datesFromLegacyAnnoLabel($label);
            $anni[] = [
                'legacy_id' => (string) ($r[0] ?? ''),
                'label' => str_replace(' - ', '-', $label),
                'start_date' => $startDate,
                'end_date' => $endDate,
            ];
        }

        $campagne = [];
        foreach (($rows['campagna'] ?? []) as $r) {
            $campagne[] = [
                'legacy_id' => (string) ($r[0] ?? ''),
                'descrizione' => (string) ($r[1] ?? ''),
                'start_date' => $this->toDateOnly((string) ($r[2] ?? '')),
                'end_date' => $this->toDateOnly((string) ($r[3] ?? '')),
            ];
        }

        $assegnazioni = [];
        foreach (($rows['assegnazione'] ?? []) as $r) {
            $assegnazioni[] = [
                'legacy_id' => (string) ($r[0] ?? ''),
                'legacy_territorio_id' => (string) ($r[1] ?? ''),
                'legacy_proclamatore_id' => (string) ($r[2] ?? ''),
                'legacy_anno_id' => (string) ($r[9] ?? ''),
                'legacy_campagna_id' => $r[8] === null ? '' : (string) $r[8],
                'assigned_at' => $this->toDateOnly((string) ($r[4] ?? '')),
                'returned_at' => $this->toDateOnly((string) ($r[5] ?? '')),
                'counted_in_campaign' => ((int) ($r[7] ?? 0)) === 1 ? 1 : 0,
                'note' => '',
            ];
        }

        return [
            'settings' => $settings,
            'zones' => $zones,
            'tipologie' => $tipologie,
            'proclamatori' => $proclamatori,
            'territori' => $territori,
            'anni_teocratici' => $anni,
            'campagne' => $campagne,
            'assegnazioni' => $assegnazioni,
        ];
    }

    private function extractInsertRows(string $sql): array
    {
        $result = [];
        preg_match_all('/INSERT INTO `([^`]+)` VALUES\s*(.+);/m', $sql, $matches, PREG_SET_ORDER);

        foreach ($matches as $match) {
            $table = $match[1];
            $valuesPayload = $match[2];
            $tuples = $this->splitSqlTuples($valuesPayload);

            foreach ($tuples as $tuple) {
                $result[$table][] = $this->parseSqlTuple($tuple);
            }
        }

        return $result;
    }

    private function splitSqlTuples(string $payload): array
    {
        $tuples = [];
        $inString = false;
        $escape = false;
        $depth = 0;
        $current = '';

        $len = strlen($payload);
        for ($i = 0; $i < $len; $i++) {
            $ch = $payload[$i];

            if ($inString) {
                $current .= $ch;
                if ($escape) {
                    $escape = false;
                    continue;
                }
                if ($ch === '\\') {
                    $escape = true;
                    continue;
                }
                if ($ch === "'") {
                    $inString = false;
                }
                continue;
            }

            if ($ch === "'") {
                $inString = true;
                $current .= $ch;
                continue;
            }

            if ($ch === '(') {
                if ($depth === 0) {
                    $current = '';
                }
                $depth++;
                continue;
            }

            if ($ch === ')') {
                $depth--;
                if ($depth === 0) {
                    $tuples[] = $current;
                    $current = '';
                    continue;
                }
            }

            if ($depth > 0) {
                $current .= $ch;
            }
        }

        return $tuples;
    }

    private function parseSqlTuple(string $tuple): array
    {
        $values = [];
        $inString = false;
        $escape = false;
        $current = '';

        $len = strlen($tuple);
        for ($i = 0; $i < $len; $i++) {
            $ch = $tuple[$i];

            if ($inString) {
                $current .= $ch;
                if ($escape) {
                    $escape = false;
                    continue;
                }
                if ($ch === '\\') {
                    $escape = true;
                    continue;
                }
                if ($ch === "'") {
                    $inString = false;
                }
                continue;
            }

            if ($ch === "'") {
                $inString = true;
                $current .= $ch;
                continue;
            }

            if ($ch === ',') {
                $values[] = $this->normalizeSqlValue($current);
                $current = '';
                continue;
            }

            $current .= $ch;
        }

        if ($current !== '') {
            $values[] = $this->normalizeSqlValue($current);
        }

        return $values;
    }

    private function normalizeSqlValue(string $raw)
    {
        $raw = trim($raw);
        if (strcasecmp($raw, 'NULL') === 0) {
            return null;
        }

        if (str_starts_with($raw, "'") && str_ends_with($raw, "'")) {
            $v = substr($raw, 1, -1);
            $v = str_replace(["\\\\", "\\'", '\\"', '\\n', '\\r', '\\t'], ['\\', "'", '"', "\n", "\r", "\t"], $v);
            $v = html_entity_decode($v, ENT_QUOTES | ENT_HTML5, 'UTF-8');
            return $this->normalizeUnicodeQuotes($v);
        }

        if (is_numeric($raw)) {
            return str_contains($raw, '.') ? (float) $raw : (int) $raw;
        }

        return $raw;
    }

    private function normalizeUnicodeQuotes(string $value): string
    {
        return str_replace(
            ["\u{2018}", "\u{2019}", "\u{2032}", "\u{2035}", "\u{201C}", "\u{201D}", "\u{201E}", "\u{2033}", "\u{2036}"],
            ["'", "'", "'", "'", '"', '"', '"', '"', '"'],
            $value
        );
    }

    private function datesFromLegacyAnnoLabel(string $label): array
    {
        if (preg_match('/(\d{4})\s*-\s*(\d{4})/', $label, $m)) {
            return [$m[1] . '-09-01', $m[2] . '-08-31'];
        }

        $now = Carbon::now();
        return [$now->copy()->startOfYear()->toDateString(), $now->copy()->endOfYear()->toDateString()];
    }

    private function toDateOnly(string $dateTime): string
    {
        if ($dateTime === '') {
            return '';
        }
        return substr($dateTime, 0, 10);
    }

    private function normalizeDateForDb(string $raw, bool $nullable): ?string
    {
        $raw = trim($raw);
        if ($raw === '' || $raw === '0000-00-00' || $raw === '0000-00-00 00:00:00') {
            return $nullable ? null : null;
        }

        try {
            return Carbon::parse($raw)->toDateString();
        } catch (\Throwable $e) {
            return $nullable ? null : null;
        }
    }

    private function pushImportIssue(string $entity, string $legacyId, string $reason): void
    {
        if (count($this->importIssues) >= 300) {
            return;
        }

        $this->importIssues[] = [
            'entity' => $entity,
            'legacy_id' => $legacyId !== '' ? $legacyId : '-',
            'reason' => $reason,
        ];
    }

    private function datasetToXml(array $dataset, string $source): string
    {
        $xml = new \SimpleXMLElement('<?xml version="1.0" encoding="UTF-8"?><termanager2/>');
        $xml->addAttribute('version', '1.0');
        $xml->addAttribute('source', $source);
        $xml->addAttribute('generated_at', now()->toIso8601String());

        $settings = $xml->addChild('settings');
        foreach ($dataset['settings'] as $key => $value) {
            $this->addXmlText($settings, $key, (string) $value);
        }

        // Users are absent from the legacy-SQL dataset, so guard with ?? [].
        $usersNode = $xml->addChild('users');
        foreach (($dataset['users'] ?? []) as $user) {
            $node = $usersNode->addChild('user');
            if (isset($user['legacy_id'])) {
                $node->addAttribute('legacy_id', (string) $user['legacy_id']);
            }
            $this->addXmlText($node, 'name', (string) ($user['name'] ?? ''));
            $this->addXmlText($node, 'email', (string) ($user['email'] ?? ''));
            $this->addXmlText($node, 'password', (string) ($user['password'] ?? ''));
            $node->addChild('email_verified_at', (string) ($user['email_verified_at'] ?? ''));
            $this->addXmlText($node, 'remember_token', (string) ($user['remember_token'] ?? ''));
            $node->addChild('created_at', (string) ($user['created_at'] ?? ''));
            $node->addChild('updated_at', (string) ($user['updated_at'] ?? ''));
            $rolesNode = $node->addChild('roles');
            foreach (($user['roles'] ?? []) as $roleName) {
                $this->addXmlText($rolesNode, 'role', (string) $roleName);
            }
        }

        $zonesNode = $xml->addChild('zones');
        foreach ($dataset['zones'] as $zone) {
            $node = $zonesNode->addChild('zone');
            $this->addLegacyIdAttribute($node, $zone);
            $this->addXmlText($node, 'nome', (string) ($zone['nome'] ?? ''));
            $node->addChild('attivo', (string) ((int) ($zone['attivo'] ?? 1)));
            $this->addTimestampNodes($node, $zone);
        }

        $tipologieNode = $xml->addChild('tipologie');
        foreach ($dataset['tipologie'] as $tipologia) {
            $node = $tipologieNode->addChild('tipologia');
            $this->addLegacyIdAttribute($node, $tipologia);
            $this->addXmlText($node, 'nome', (string) ($tipologia['nome'] ?? ''));
            $node->addChild('attivo', (string) ((int) ($tipologia['attivo'] ?? 1)));
            $this->addTimestampNodes($node, $tipologia);
        }

        $proclamatoriNode = $xml->addChild('proclamatori');
        foreach ($dataset['proclamatori'] as $proclamatore) {
            $node = $proclamatoriNode->addChild('proclamatore');
            $this->addLegacyIdAttribute($node, $proclamatore);
            $this->addXmlText($node, 'nome', (string) ($proclamatore['nome'] ?? ''));
            $this->addXmlText($node, 'cognome', (string) ($proclamatore['cognome'] ?? ''));
            $node->addChild('attivo', (string) ((int) ($proclamatore['attivo'] ?? 1)));
            $node->addChild('deleted_at', (string) ($proclamatore['deleted_at'] ?? ''));
            $this->addTimestampNodes($node, $proclamatore);
        }

        $territoriNode = $xml->addChild('territori');
        foreach ($dataset['territori'] as $territorio) {
            $node = $territoriNode->addChild('territorio');
            $this->addLegacyIdAttribute($node, $territorio);
            $this->addXmlText($node, 'numero', (string) ($territorio['numero'] ?? ''));
            $node->addChild('legacy_zona_id', (string) ($territorio['legacy_zona_id'] ?? ($territorio['zona_id'] ?? '')));
            $node->addChild('legacy_tipologia_id', (string) ($territorio['legacy_tipologia_id'] ?? ($territorio['tipologia_id'] ?? '')));
            $this->addXmlText($node, 'confini', (string) ($territorio['confini'] ?? ''));
            $this->addXmlText($node, 'note', (string) ($territorio['note'] ?? ''));
            $node->addChild('attivo', (string) ((int) ($territorio['attivo'] ?? 1)));
            $node->addChild('prioritario', (string) ((int) ($territorio['prioritario'] ?? 0)));
            $this->addXmlText($node, 'pdf_path', (string) ($territorio['pdf_path'] ?? ''));
            $this->addXmlText($node, 'thumbnail_path', (string) ($territorio['thumbnail_path'] ?? ''));
            $node->addChild('deleted_at', (string) ($territorio['deleted_at'] ?? ''));
            $this->addTimestampNodes($node, $territorio);
        }

        $anniNode = $xml->addChild('anni_teocratici');
        foreach ($dataset['anni_teocratici'] as $anno) {
            $node = $anniNode->addChild('anno');
            $this->addLegacyIdAttribute($node, $anno);
            $this->addXmlText($node, 'label', (string) ($anno['label'] ?? ''));
            $node->addChild('start_date', (string) ($anno['start_date'] ?? ''));
            $node->addChild('end_date', (string) ($anno['end_date'] ?? ''));
            $this->addTimestampNodes($node, $anno);
        }

        $campagneNode = $xml->addChild('campagne');
        foreach ($dataset['campagne'] as $campagna) {
            $node = $campagneNode->addChild('campagna');
            $this->addLegacyIdAttribute($node, $campagna);
            $this->addXmlText($node, 'descrizione', (string) ($campagna['descrizione'] ?? ''));
            $node->addChild('start_date', (string) ($campagna['start_date'] ?? ''));
            $node->addChild('end_date', (string) ($campagna['end_date'] ?? ''));
            $this->addTimestampNodes($node, $campagna);
        }

        $assegnazioniNode = $xml->addChild('assegnazioni');
        foreach ($dataset['assegnazioni'] as $assegnazione) {
            $node = $assegnazioniNode->addChild('assegnazione');
            $this->addLegacyIdAttribute($node, $assegnazione);
            $node->addChild('legacy_territorio_id', (string) ($assegnazione['legacy_territorio_id'] ?? ($assegnazione['territorio_id'] ?? '')));
            $node->addChild('legacy_proclamatore_id', (string) ($assegnazione['legacy_proclamatore_id'] ?? ($assegnazione['proclamatore_id'] ?? '')));
            $node->addChild('legacy_anno_id', (string) ($assegnazione['legacy_anno_id'] ?? ($assegnazione['anno_teocratico_id'] ?? '')));
            $node->addChild('legacy_campagna_id', (string) ($assegnazione['legacy_campagna_id'] ?? ($assegnazione['campaign_id'] ?? '')));
            $node->addChild('legacy_created_by_id', (string) ($assegnazione['legacy_created_by_id'] ?? ($assegnazione['created_by'] ?? '')));
            $node->addChild('legacy_returned_by_id', (string) ($assegnazione['legacy_returned_by_id'] ?? ($assegnazione['returned_by'] ?? '')));
            $node->addChild('assigned_at', (string) ($assegnazione['assigned_at'] ?? ''));
            $node->addChild('returned_at', (string) ($assegnazione['returned_at'] ?? ''));
            $node->addChild('counted_in_campaign', (string) ((int) ($assegnazione['counted_in_campaign'] ?? 0)));
            $node->addChild('link_sent', (string) ((int) ($assegnazione['link_sent'] ?? 0)));
            $this->addXmlText($node, 'pdf_access_code', (string) ($assegnazione['pdf_access_code'] ?? ''));
            $this->addXmlText($node, 'note', (string) ($assegnazione['note'] ?? ''));
            $this->addTimestampNodes($node, $assegnazione);
        }

        return $xml->asXML() ?: '';
    }

    private function addXmlText(\SimpleXMLElement $parent, string $name, string $value): \SimpleXMLElement
    {
        $child = $parent->addChild($name);
        $dom = dom_import_simplexml($child);
        $dom->textContent = $value;

        return $child;
    }

    private function addTimestampNodes(\SimpleXMLElement $node, array $row): void
    {
        $node->addChild('created_at', (string) ($row['created_at'] ?? ''));
        $node->addChild('updated_at', (string) ($row['updated_at'] ?? ''));
    }

    /**
     * Write the legacy_id attribute used to remap foreign keys on import.
     * The legacy-SQL conversion supplies an explicit 'legacy_id'; the
     * current-app export supplies the real 'id' — either works as the stable
     * key the referencing rows (territori, assegnazioni, …) point back to.
     */
    private function addLegacyIdAttribute(\SimpleXMLElement $node, array $row): void
    {
        $legacyId = $row['legacy_id'] ?? $row['id'] ?? null;
        if ($legacyId !== null && (string) $legacyId !== '') {
            $node->addAttribute('legacy_id', (string) $legacyId);
        }
    }

    /**
     * Parse a full datetime (created_at/updated_at/deleted_at/email_verified_at)
     * for storage, returning a `Y-m-d H:i:s` string or null. Unlike
     * normalizeDateForDb this keeps the time component.
     */
    private function normalizeDateTimeForDb(string $raw): ?string
    {
        $raw = trim($raw);
        if ($raw === '' || str_starts_with($raw, '0000-00-00')) {
            return null;
        }

        try {
            return Carbon::parse($raw)->toDateTimeString();
        } catch (\Throwable $e) {
            return null;
        }
    }

    /**
     * Restore created_at/updated_at (and deleted_at, when the model soft
     * deletes) from the XML node after the row has been created. Written with
     * the query builder so Eloquent does not stamp its own timestamps over the
     * imported values. Only columns present in the XML are touched.
     */
    private function applyRowMeta(string $table, int $id, \SimpleXMLElement $node, bool $withSoftDelete = false): void
    {
        $updates = [];

        $createdAt = $this->normalizeDateTimeForDb((string) ($node->created_at ?? ''));
        if ($createdAt !== null) {
            $updates['created_at'] = $createdAt;
        }

        $updatedAt = $this->normalizeDateTimeForDb((string) ($node->updated_at ?? ''));
        if ($updatedAt !== null) {
            $updates['updated_at'] = $updatedAt;
        }

        if ($withSoftDelete) {
            $deletedAt = $this->normalizeDateTimeForDb((string) ($node->deleted_at ?? ''));
            if ($deletedAt !== null) {
                $updates['deleted_at'] = $deletedAt;
            }
        }

        if ($updates !== []) {
            DB::table($table)->where('id', $id)->update($updates);
        }
    }
}