<?php

declare(strict_types=1);

namespace Tests\Feature;

use App\Livewire\Counter;
use App\Models\Tracker;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Livewire\Livewire;
use PHPUnit\Framework\Attributes\DataProvider;
use Tests\TestCase;

class CounterTest extends TestCase
{
    use RefreshDatabase;

    private function tracker(int $count = 0): Tracker
    {
        return Tracker::factory()->create(['count' => $count]);
    }

    public function test_the_page_renders_the_current_count(): void
    {
        $this->tracker(42);

        $this->get('/')
            ->assertOk()
            ->assertSee('42');
    }

    public function test_increment_adds_exactly_one(): void
    {
        $tracker = $this->tracker(5);

        Livewire::test(Counter::class)
            ->call('increment')
            ->assertSet('count', 6);

        $this->assertSame(6, $tracker->refresh()->count);
    }

    public function test_increments_accumulate(): void
    {
        $tracker = $this->tracker();

        Livewire::test(Counter::class)
            ->call('increment')
            ->call('increment')
            ->call('increment')
            ->assertSet('count', 3);

        $this->assertSame(3, $tracker->refresh()->count);
    }

    public function test_count_can_be_set_to_an_absolute_value(): void
    {
        $tracker = $this->tracker(3);

        Livewire::test(Counter::class)
            ->call('edit')
            ->set('value', 250)
            ->call('save')
            ->assertSet('count', 250)
            ->assertSet('editing', false);

        $this->assertSame(250, $tracker->refresh()->count);
    }

    public function test_count_can_be_set_to_zero(): void
    {
        $tracker = $this->tracker(42);

        Livewire::test(Counter::class)
            ->call('edit')
            ->set('value', 0)
            ->call('save');

        $this->assertSame(0, $tracker->refresh()->count);
    }

    /**
     * @return array<string, array{mixed}>
     */
    public static function invalidCounts(): array
    {
        return [
            'negative' => [-1],
            'above unsigned int ceiling' => [4294967296],
        ];
    }

    #[DataProvider('invalidCounts')]
    public function test_save_rejects_invalid_values(mixed $value): void
    {
        $tracker = $this->tracker(7);

        Livewire::test(Counter::class)
            ->call('edit')
            ->set('value', $value)
            ->call('save')
            ->assertHasErrors('value');

        $this->assertSame(7, $tracker->refresh()->count);
    }

    public function test_cancel_discards_the_edit(): void
    {
        $tracker = $this->tracker(9);

        Livewire::test(Counter::class)
            ->call('edit')
            ->set('value', 500)
            ->call('cancel')
            ->assertSet('count', 9)
            ->assertSet('editing', false);

        $this->assertSame(9, $tracker->refresh()->count);
    }

    public function test_increment_stops_at_the_column_ceiling(): void
    {
        $tracker = $this->tracker(Counter::MAX_COUNT);

        Livewire::test(Counter::class)
            ->call('increment')
            ->assertSet('count', Counter::MAX_COUNT);

        $this->assertSame(Counter::MAX_COUNT, $tracker->refresh()->count);
    }

    public function test_count_is_cast_to_an_integer(): void
    {
        $this->tracker(12);

        $this->assertSame(12, Tracker::first()->count);
    }
}