<?php

namespace Tests\Feature;

use App\Livewire\Piantine\PiantineEditor;
use App\Models\Setting;
use App\Models\Territorio;
use App\Models\TerritorioMappa;
use App\Models\Tipologia;
use App\Models\User;
use App\Models\Zona;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Facades\Storage;
use Livewire\Livewire;
use Spatie\Permission\Models\Role;
use Spatie\Permission\PermissionRegistrar;
use Tests\TestCase;

/**
 * L'editor a schermo intero: si disegna prima e si decide dopo a chi
 * appartiene il disegno — territorio compreso, che può nascere qui.
 */
class PiantineEditorTest extends TestCase
{
    use RefreshDatabase;

    private const GEOMETRIA = [
        'type' => 'Polygon',
        'coordinates' => [[[13.35, 38.11], [13.37, 38.11], [13.37, 38.13], [13.35, 38.11]]],
    ];

    protected function setUp(): void
    {
        parent::setUp();
        $this->withoutVite();
        Storage::fake('public');
        Storage::fake('local');
    }

    public function test_la_pagina_e_riservata_all_amministratore(): void
    {
        Role::findOr('utente', fn () => Role::create(['name' => 'utente', 'guard_name' => 'web']));
        app(PermissionRegistrar::class)->forgetCachedPermissions();

        $utente = User::create([
            'name' => 'Utente semplice',
            'email' => 'utente@example.test',
            'password' => 'password-di-prova',
        ]);
        $utente->assignRole('utente');

        $this->actingAs($utente)->get(route('piantine.editor'))->assertForbidden();
        $this->actingAs($this->admin())->get(route('piantine.editor'))->assertOk();
    }

    public function test_una_piantina_si_salva_senza_nessun_territorio(): void
    {
        Livewire::actingAs($this->admin())
            ->test(PiantineEditor::class)
            ->dispatch('poligono-disegnato', geometry: self::GEOMETRIA)
            ->set('nome', 'Zona porto — lato nord')
            ->call('salva');

        $mappa = TerritorioMappa::sole();
        $this->assertNull($mappa->territorio_id);
        $this->assertSame('Zona porto — lato nord', $mappa->nome);
        $this->assertSame(self::GEOMETRIA, $mappa->geometria());
        $this->assertSame('Zona porto — lato nord', $mappa->etichetta());
    }

    public function test_il_territorio_si_crea_dalla_scheda_con_tutte_le_proprieta(): void
    {
        $zona = Zona::create(['nome' => 'Nord', 'attivo' => true]);
        $tipologia = Tipologia::create(['nome' => 'Residenziale', 'attivo' => true]);

        Livewire::actingAs($this->admin())
            ->test(PiantineEditor::class)
            ->dispatch('poligono-disegnato', geometry: self::GEOMETRIA)
            ->set('territorioScelto', 'nuovo')
            ->set('numero', '42')
            ->set('zonaId', (string) $zona->id)
            ->set('tipologiaId', (string) $tipologia->id)
            ->set('confini', "Nord: via Roma\nSud: via Milano")
            ->call('salva')
            ->assertHasNoErrors();

        $territorio = Territorio::where('numero', '42')->sole();
        $this->assertTrue((bool) $territorio->attivo);
        $this->assertSame($zona->id, $territorio->zona_id);
        $this->assertSame($tipologia->id, $territorio->tipologia_id);
        $this->assertStringContainsString('via Roma', $territorio->confini);
        $this->assertSame($territorio->id, TerritorioMappa::sole()->territorio_id);
    }

    public function test_la_scheda_aggiorna_un_territorio_gia_esistente(): void
    {
        $territorio = Territorio::create(['numero' => '12', 'attivo' => true]);

        Livewire::actingAs($this->admin())
            ->test(PiantineEditor::class)
            ->dispatch('poligono-disegnato', geometry: self::GEOMETRIA)
            ->set('territorioScelto', (string) $territorio->id)
            ->set('numero', '12')
            ->set('confini', 'Nord: via Verdi')
            ->call('salva')
            ->assertHasNoErrors();

        $this->assertSame('Nord: via Verdi', $territorio->fresh()->confini);
        $this->assertSame(1, Territorio::count());
    }

    public function test_zona_e_tipologia_si_creano_dall_editor_e_restano_selezionate(): void
    {
        $componente = Livewire::actingAs($this->admin())
            ->test(PiantineEditor::class)
            ->set('territorioScelto', 'nuovo')
            ->set('nuovaZona', 'Litorale')
            ->call('creaZona')
            ->assertHasNoErrors()
            ->set('nuovaTipologia', 'Commerciale')
            ->call('creaTipologia')
            ->assertHasNoErrors();

        $zona = Zona::where('nome', 'Litorale')->sole();
        $tipologia = Tipologia::where('nome', 'Commerciale')->sole();

        $componente->assertSet('zonaId', (string) $zona->id);
        $componente->assertSet('tipologiaId', (string) $tipologia->id);
    }

    public function test_una_zona_gia_esistente_non_viene_duplicata(): void
    {
        Zona::create(['nome' => 'Nord', 'attivo' => true]);

        Livewire::actingAs($this->admin())
            ->test(PiantineEditor::class)
            ->set('nuovaZona', 'Nord')
            ->call('creaZona')
            ->assertHasErrors('nuovaZona');

        $this->assertSame(1, Zona::where('nome', 'Nord')->count());
    }

    public function test_un_numero_gia_in_uso_non_crea_un_secondo_territorio(): void
    {
        Territorio::create(['numero' => '42', 'attivo' => true]);

        Livewire::actingAs($this->admin())
            ->test(PiantineEditor::class)
            ->dispatch('poligono-disegnato', geometry: self::GEOMETRIA)
            ->set('territorioScelto', 'nuovo')
            ->set('numero', '42')
            ->call('salva')
            ->assertHasErrors('numero');

        $this->assertSame(1, Territorio::where('numero', '42')->count());
        $this->assertSame(0, TerritorioMappa::count());
    }

    public function test_ridisegnare_sostituisce_il_poligono_senza_duplicare_la_piantina(): void
    {
        $mappa = TerritorioMappa::create([
            'nome' => 'Zona porto',
            'geojson' => '{"type":"Polygon","coordinates":[[[0,0],[1,0],[1,1],[0,0]]]}',
        ]);

        Livewire::actingAs($this->admin())
            ->test(PiantineEditor::class, ['mappa' => $mappa->id])
            ->dispatch('poligono-disegnato', geometry: self::GEOMETRIA)
            ->call('salva');

        $this->assertSame(1, TerritorioMappa::count());
        $this->assertSame(self::GEOMETRIA, $mappa->fresh()->geometria());
    }

    public function test_una_geometria_non_valida_viene_ignorata(): void
    {
        Livewire::actingAs($this->admin())
            ->test(PiantineEditor::class)
            ->dispatch('poligono-disegnato', geometry: ['type' => 'Point', 'coordinates' => [1, 2]])
            ->call('salva');

        $this->assertSame(0, TerritorioMappa::count());
    }

    public function test_non_si_ruba_il_territorio_a_un_altra_piantina(): void
    {
        $territorio = Territorio::create(['numero' => '12', 'attivo' => true]);
        TerritorioMappa::create([
            'territorio_id' => $territorio->id,
            'geojson' => json_encode(self::GEOMETRIA),
        ]);

        Livewire::actingAs($this->admin())
            ->test(PiantineEditor::class)
            ->dispatch('poligono-disegnato', geometry: self::GEOMETRIA)
            ->set('territorioScelto', (string) $territorio->id)
            ->set('numero', $territorio->numero)
            ->call('salva');

        // La seconda piantina non deve essere stata creata.
        $this->assertSame(1, TerritorioMappa::count());
    }

    private function admin(): User
    {
        Role::findOr('amministratore', fn () => Role::create(['name' => 'amministratore', 'guard_name' => 'web']));
        app(PermissionRegistrar::class)->forgetCachedPermissions();

        Setting::firstOrCreate([], ['congregazione_nome' => 'Congregazione di prova']);

        $utente = User::firstOrCreate(
            ['email' => 'admin@example.test'],
            ['name' => 'Amministratore', 'password' => 'password-di-prova'],
        );
        $utente->assignRole('amministratore');

        return $utente;
    }
}