<?php

namespace Tests\Feature;

use App\Filament\Resources\ModelloResource\Pages\EditModello;
use App\Models\ListinoPrezzo;
use App\Models\Modello;
use App\Models\User;
use App\Support\Configuratore\CompressoreGlb;
use App\Support\Configuratore\Modelli3d;
use Database\Seeders\CatalogoSeeder;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\File;
use Illuminate\Support\Facades\Storage;
use Livewire\Livewire;
use Tests\TestCase;

class Modelli3dTest extends TestCase
{
    use RefreshDatabase;

    private Modello $finestra;

    protected function setUp(): void
    {
        parent::setUp();

        Storage::fake('public');
        Storage::fake('local');
        $this->seed(CatalogoSeeder::class);
        $this->actingAs(User::factory()->create(['is_superadmin' => true]));

        $this->finestra = Modello::where('codice', 'finestra_1_anta')->firstOrFail();
        ListinoPrezzo::create(['modello_id' => $this->finestra->id, 'larghezza' => 1000, 'altezza' => 1000, 'prezzo' => 100]);

        // Niente Node nei test: la "compressione" tiene i primi 16 byte del file.
        $this->app->instance(CompressoreGlb::class, new class extends CompressoreGlb
        {
            public function comprimi(string $sorgente, string $destinazione): void
            {
                file_put_contents($destinazione, substr(file_get_contents($sorgente), 0, 16));
            }
        });
    }

    /** Intestazione GLB valida (magic, versione 2, lunghezza) seguita da $corpo. */
    private function glb(string $corpo = 'geometria di prova'): string
    {
        return 'glTF'.pack('V', 2).pack('V', 12 + strlen($corpo)).$corpo;
    }

    private function carica(UploadedFile $file)
    {
        return Livewire::test(EditModello::class, ['record' => $this->finestra->getRouteKey()])
            ->fillForm(['modello_3d_upload' => $file])
            ->call('save');
    }

    public function test_il_caricamento_salva_originale_e_copia_draco(): void
    {
        $this->carica(UploadedFile::fake()->createWithContent('finestra.glb', $this->glb()))
            ->assertHasNoFormErrors();

        $this->finestra->refresh();
        $this->assertSame('finestra.glb', $this->finestra->modello_3d_nome);
        $this->assertStringStartsWith('modelli-3d/originali/pvc/finestra_1_anta-', $this->finestra->modello_3d);
        $this->assertStringStartsWith('modelli-3d/draco/pvc/finestra_1_anta-', $this->finestra->modello_3d_draco);
        $this->assertSame($this->glb(), Storage::disk('local')->get($this->finestra->modello_3d));
        $this->assertSame(substr($this->glb(), 0, 16), Storage::disk('public')->get($this->finestra->modello_3d_draco));
        $this->assertSame(strlen($this->glb()), $this->finestra->modello_3d_dimensione);
        $this->assertSame(16, $this->finestra->modello_3d_draco_dimensione);

        // La scheda mostra il modello attuale con le dimensioni prima/dopo.
        Livewire::test(EditModello::class, ['record' => $this->finestra->getRouteKey()])
            ->assertOk()
            ->assertSee('finestra.glb')
            ->assertSee('con Draco')
            ->assertSee('Sostituisci modello 3D')
            // callFormComponentAction() cerca la chiave sotto "data.", che un Placeholder non ha.
            // Senza modale, il mount esegue subito l'azione.
            ->call('mountFormComponentAction', 'modello_3d_attuale', 'scarica_originale')
            ->assertFileDownloaded('finestra.glb');

        // L'originale non è sul disco pubblico.
        Storage::disk('public')->assertMissing($this->finestra->modello_3d);

        // Il configuratore riceve l'URL della copia Draco, servita con CORS e cache lunga.
        $modello = collect($this->getJson('/api/sistemi')->json('0.modelli'))->firstWhere('id', 'finestra_1_anta');
        $this->assertSame($this->finestra->modello_3d_url, $modello['modello_url']);

        $this->get($modello['modello_url'])
            ->assertOk()
            ->assertHeader('Content-Type', 'model/gltf-binary')
            ->assertHeader('Cache-Control', 'immutable, max-age=31536000, public');
    }

    public function test_un_file_non_glb_e_rifiutato_senza_toccare_il_modello(): void
    {
        $this->carica(UploadedFile::fake()->createWithContent('finestra.glb', 'non sono un glb'))
            ->assertHasFormErrors(['modello_3d_upload']);

        $this->assertNull($this->finestra->refresh()->modello_3d);
        $this->assertEmpty(Storage::disk('local')->allFiles('modelli-3d'));
    }

    public function test_una_compressione_fallita_annulla_il_salvataggio(): void
    {
        $this->app->instance(CompressoreGlb::class, new class extends CompressoreGlb
        {
            public function comprimi(string $sorgente, string $destinazione): void
            {
                throw new \App\Support\Configuratore\Modello3dNonValido('Compressione Draco non riuscita: test.');
            }
        });

        Livewire::test(EditModello::class, ['record' => $this->finestra->getRouteKey()])
            ->fillForm(['nome' => 'Nome cambiato', 'modello_3d_upload' => UploadedFile::fake()->createWithContent('f.glb', $this->glb())])
            ->call('save')
            ->assertHasFormErrors(['modello_3d_upload']);

        $this->finestra->refresh();
        $this->assertNull($this->finestra->modello_3d);
        $this->assertNotSame('Nome cambiato', $this->finestra->nome);
    }

    public function test_sostituzione_ed_eliminazione_rimuovono_i_file_precedenti(): void
    {
        $servizio = app(Modelli3d::class);
        $sorgente = tempnam(sys_get_temp_dir(), 'glb');

        file_put_contents($sorgente, $this->glb('primo'));
        $servizio->carica($this->finestra, $sorgente);
        [$originale, $draco] = [$this->finestra->modello_3d, $this->finestra->modello_3d_draco];

        file_put_contents($sorgente, $this->glb('secondo, diverso nei primi byte'));
        $servizio->carica($this->finestra, $sorgente);
        unlink($sorgente);

        Storage::disk('local')->assertMissing($originale);
        Storage::disk('public')->assertMissing($draco);
        Storage::disk('local')->assertExists($this->finestra->modello_3d);

        $this->finestra->delete();
        Storage::disk('local')->assertMissing($this->finestra->modello_3d);
        Storage::disk('public')->assertMissing($this->finestra->modello_3d_draco);
    }

    public function test_senza_modello_3d_il_modello_non_e_nel_configuratore(): void
    {
        $this->getJson('/api/sistemi/pvc/modelli/finestra_1_anta/configurazione')->assertNotFound();
    }

    public function test_il_comando_importa_i_glb_del_configuratore(): void
    {
        $cartella = sys_get_temp_dir().'/modelli-'.uniqid();
        File::ensureDirectoryExists("{$cartella}/pvc");
        file_put_contents("{$cartella}/pvc/finestra_1_anta.glb", $this->glb());

        $this->artisan('modelli3d:importa', ['cartella' => $cartella])->assertSuccessful();
        File::deleteDirectory($cartella);

        $this->finestra->refresh();
        $this->assertSame('finestra_1_anta.glb', $this->finestra->modello_3d_nome);
        Storage::disk('public')->assertExists($this->finestra->modello_3d_draco);
    }

    public function test_compressione_draco_reale_con_node(): void
    {
        $script = config('configuratore.modelli_3d.script');
        $celino = base_path('../src/assets/models/pvc/celino.glb');
        if (! is_dir(dirname($script, 2).'/node_modules/@gltf-transform/core') || ! is_file($celino)) {
            $this->markTestSkipped('Dipendenze Node o modello di prova non installati.');
        }

        $this->app->forgetInstance(CompressoreGlb::class);
        $this->app->offsetUnset(CompressoreGlb::class);

        app(Modelli3d::class)->carica($this->finestra, $celino);

        $draco = Storage::disk('public')->get($this->finestra->modello_3d_draco);
        $this->assertStringStartsWith('glTF', $draco);
        $this->assertStringContainsString('KHR_draco_mesh_compression', $draco);
        $this->assertLessThan(filesize($celino), strlen($draco));
    }
}