<?php

namespace Database\Seeders;

use App\Models\Finitura;
use App\Models\Modello;
use App\Models\Opzione;
use App\Models\RegolaVetro;
use App\Models\Sistema;
use App\Models\Vetro;
use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Storage;

/**
 * Catalogo iniziale del configuratore PVC (finiture, maniglie, vetri, regole vetro,
 * opzioni e supplementi) con le immagini della nuova grafica. Gira una volta sola: se il
 * sistema ha già finiture o vetri non tocca nulla, per non sovrascrivere il backoffice.
 */
class ConfiguratoreSeeder extends Seeder
{
    private const SORGENTE = __DIR__.'/data/configuratore/pvc';

    private const DESTINAZIONE = 'configuratore/pvc';

    public function run(): void
    {
        $pvc = Sistema::where('codice', 'pvc')->first();
        if (! $pvc || $pvc->finiture()->exists() || $pvc->vetri()->exists()) {
            return;
        }

        $catalogo = require __DIR__.'/data/configuratore_pvc_catalogo.php';
        $regole = require __DIR__.'/data/configuratore_pvc.php';

        DB::transaction(function () use ($pvc, $catalogo, $regole) {
            $this->finiture($pvc, 'profilo', $catalogo['finiture']);
            $this->finiture($pvc, 'maniglia', $catalogo['maniglie']);
            $this->vetri($pvc, $regole['vetri']);
            $this->opzioni($pvc, $regole['opzioni']);
            $this->modelli($pvc, $regole, $catalogo['titoli']);
        });
    }

    private function finiture(Sistema $sistema, string $tipo, array $finiture): void
    {
        foreach ($finiture as $i => $f) {
            Finitura::create([
                'sistema_id' => $sistema->id,
                'tipo' => $tipo,
                'ordine' => $i + 1,
                'anteprima' => $this->copia($f['anteprima']),
                'texture' => $this->copia($f['texture'] ?? null),
            ] + $f);
        }
    }

    private function vetri(Sistema $sistema, array $vetri): void
    {
        foreach ($vetri as $i => [$codice, $descrizione, $maggiorazione, $minimo, $icona, $aspetto]) {
            Vetro::create([
                'sistema_id' => $sistema->id,
                'codice' => $codice,
                'descrizione' => $descrizione,
                'maggiorazione_mq' => $maggiorazione,
                'minimo_mq' => $minimo,
                'ordine' => $i + 1,
                'anteprima' => $this->copia("vetri/icone/{$icona}", "vetri/{$codice}/{$icona}"),
                // Ogni vetro ha la sua copia della texture: i file non sono mai condivisi tra record.
                'texture_bump' => isset($aspetto['texture_bump'])
                    ? $this->copia($aspetto['texture_bump'], "vetri/{$codice}/".basename($aspetto['texture_bump']))
                    : null,
            ] + array_diff_key($aspetto, ['texture_bump' => true]));
        }
    }

    private function opzioni(Sistema $sistema, array $gruppi): void
    {
        foreach ($gruppi as $gruppo => $voci) {
            foreach ($voci as $i => $voce) {
                [$valore, $etichetta, $tipo, $supplemento, $icona, $parametri] = $voce;

                Opzione::create([
                    'sistema_id' => $sistema->id,
                    'gruppo' => $gruppo,
                    'valore' => $valore,
                    'etichetta' => $etichetta,
                    'supplemento_tipo' => $tipo,
                    'supplemento' => $supplemento,
                    'icona' => $icona ? $this->copia("opzioni/{$icona}", "opzioni/sistema/{$icona}") : null,
                    'parametri' => $parametri,
                    'ordine' => $i + 1,
                    'attivo' => $voce[6] ?? true,
                ]);
            }
        }
    }

    private function modelli(Sistema $sistema, array $regole, array $titoli): void
    {
        $regoleVetro = collect($regole['regole_vetro'])->map(fn (array $r, string $codice) => RegolaVetro::create([
            'sistema_id' => $sistema->id,
            'codice' => $codice,
            'descrizione' => $r[0],
            'lastre' => $r[1],
        ]));

        foreach ($sistema->modelli()->get() as $modello) {
            [$regola, $moduli] = $regole['modelli'][$modello->codice] ?? [null, []];

            $modello->update([
                'titolo' => $modello->titolo ?: ($titoli[$modello->cartella ?? $modello->codice] ?? null),
                'regola_vetro_id' => $modello->regola_vetro_id ?? $regoleVetro->get($regola)?->id,
                'moduli' => array_values(array_unique([...($modello->moduli ?? []), ...$moduli])),
            ]);

            $this->apertura($modello);
            $this->aggiornaIcona($modello);
        }
    }

    /** Icone DX/SX proprie del modello: override del gruppo apertura del sistema. */
    private function apertura(Modello $modello): void
    {
        $cartella = "opzioni/apertura/{$modello->codice}";
        if (! is_dir(self::SORGENTE."/{$cartella}")) {
            return;
        }

        foreach ([['dx', 'DX', 'destra.jpg', 1], ['sx', 'SX', 'sinistra.jpg', -1]] as $i => [$valore, $etichetta, $file, $scala]) {
            Opzione::create([
                'sistema_id' => $modello->sistema_id,
                'modello_id' => $modello->id,
                'gruppo' => 'apertura',
                'valore' => $valore,
                'etichetta' => $etichetta,
                'icona' => $this->copia("{$cartella}/{$file}"),
                'parametri' => ['scale_x' => $scala],
                'ordine' => $i + 1,
            ]);
        }
    }

    /** Sostituisce l'icona del modello con quella della nuova grafica, se non è stata cambiata dal pannello. */
    private function aggiornaIcona(Modello $modello): void
    {
        $sorgente = __DIR__."/data/icone/pvc/{$modello->codice}.jpg";
        $seminata = "modelli/icone/pvc/{$modello->codice}.jpg";

        if (is_file($sorgente) && in_array($modello->icona, [null, $seminata], true)) {
            Storage::disk('public')->put($seminata, file_get_contents($sorgente));
            $modello->updateQuietly(['icona' => $seminata]);
        }
    }

    /** Copia un file della grafica sul disco public; restituisce il percorso salvato. */
    private function copia(?string $relativo, ?string $destinazione = null): ?string
    {
        if (! $relativo) {
            return null;
        }

        $percorso = self::DESTINAZIONE.'/'.($destinazione ?? $relativo);
        Storage::disk('public')->put($percorso, file_get_contents(self::SORGENTE."/{$relativo}"));

        return $percorso;
    }
}