<?php

use App\Livewire\Admin\AdminSettings;
use App\Models\Setting;
use App\Models\User;
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Storage;
use Livewire\Livewire;

test('admin settings requires authentication', function () {
    $response = $this->get(route('admin.settings'));

    $response->assertRedirect(route('login'));
});

test('non-admin user cannot access settings', function () {
    $user = User::factory()->create(['is_admin' => false]);

    $response = $this->actingAs($user)->get(route('admin.settings'));

    $response->assertForbidden();
});

test('admin can access settings page', function () {
    $admin = User::query()->where('is_admin', true)->first();

    $response = $this->actingAs($admin)->get(route('admin.settings'));

    $response->assertOk();
});

test('admin can save settings', function () {
    $admin = User::query()->where('is_admin', true)->first();

    Livewire::actingAs($admin)
        ->test(AdminSettings::class)
        ->set('maxFileSize', 200)
        ->set('maxStorageQuota', 50)
        ->set('maxFilesPerShare', 100)
        ->set('maxSizePerShare', 5)
        ->set('defaultExpiration', '7d')
        ->call('saveSettings')
        ->assertHasNoErrors()
        ->assertDispatched('toast', type: 'success', title: 'Settings saved successfully.');

    expect(Setting::get('max_file_size'))->toBe((string) (200 * 1024 * 1024));
    expect(Setting::get('max_storage_quota'))->toBe((string) (50 * 1024 * 1024 * 1024));
    expect(Setting::get('max_files_per_share'))->toBe('100');
    expect(Setting::get('max_size_per_share'))->toBe((string) (5 * 1024 * 1024 * 1024));
    expect(Setting::get('default_expiration'))->toBe('7d');
});

test('admin can set system password', function () {
    $admin = User::query()->where('is_admin', true)->first();
    Livewire::actingAs($admin)
        ->test(AdminSettings::class)
        ->set('maxFileSize', 100)
        ->set('systemPassword', 'new-system-password')
        ->call('saveSettings')
        ->assertHasNoErrors();

    $storedPassword = Setting::get('system_password');
    expect($storedPassword)->not->toBeNull();
    expect(Hash::check('new-system-password', $storedPassword))->toBeTrue();
});

test('admin can clear system password', function () {
    $admin = User::query()->where('is_admin', true)->first();

    Setting::set('system_password', bcrypt('existing-password'));

    Livewire::actingAs($admin)
        ->test(AdminSettings::class)
        ->set('confirmingPasswordRemoval', true)
        ->call('clearSystemPassword')
        ->assertHasNoErrors()
        ->assertSet('confirmingPasswordRemoval', false)
        ->assertDispatched('toast', type: 'success', title: 'System password cleared.');

    expect(Setting::get('system_password'))->toBeNull();
});

test('settings page loads existing values', function () {
    $admin = User::query()->where('is_admin', true)->first();
    $testSize = 40;

    Setting::set('max_file_size', $testSize * 1024 * 1024);
    Setting::set('max_files_per_share', 75);

    Livewire::actingAs($admin)
        ->test(AdminSettings::class)
        ->assertSet('maxFileSize', $testSize)
        ->assertSet('maxFilesPerShare', 75);
});

test('settings validation rejects invalid values', function () {
    $admin = User::query()->where('is_admin', true)->first();

    Livewire::actingAs($admin)
        ->test(AdminSettings::class)
        ->set('maxFileSize', 0)
        ->set('maxStorageQuota', 0)
        ->call('saveSettings')
        ->assertHasErrors(['maxFileSize', 'maxStorageQuota']);
});

test('admin can remove the logo through its dialog', function () {
    Storage::fake('public');

    $admin = User::query()->where('is_admin', true)->first();
    $path = UploadedFile::fake()->image('logo.png')->store('branding', 'public');
    Setting::set('site_logo', $path);

    Livewire::actingAs($admin)
        ->test(AdminSettings::class)
        ->assertSeeHtml('data-test="remove-logo"')
        ->set('confirmingLogoRemoval', true)
        ->call('removeLogo')
        ->assertSet('confirmingLogoRemoval', false)
        ->assertDispatched('toast', type: 'success', title: 'Logo removed.');

    expect(Setting::get('site_logo'))->toBeNull();
    Storage::disk('public')->assertMissing($path);
});

test('admin chooses the colour profile, starting from the saved one', function () {
    $admin = User::query()->where('is_admin', true)->first();

    Livewire::actingAs($admin)
        ->test(AdminSettings::class)
        ->assertSet('colorProfile', 'indigo')
        ->set('colorProfile', 'teal')
        ->call('saveSettings')
        ->assertHasNoErrors();

    expect(Setting::get('color_profile'))->toBe('teal');

    Livewire::actingAs($admin)
        ->test(AdminSettings::class)
        ->assertSet('colorProfile', 'teal');
});

test('a colour profile that was not generated is refused', function () {
    $admin = User::query()->where('is_admin', true)->first();

    Livewire::actingAs($admin)
        ->test(AdminSettings::class)
        ->set('colorProfile', 'ocean')
        ->call('saveSettings')
        ->assertHasErrors(['colorProfile' => 'in']);

    expect(Setting::get('color_profile'))->toBeNull();
});

test('admin saves a character password generator, starting from the saved settings', function () {
    $admin = User::query()->where('is_admin', true)->first();

    Livewire::actingAs($admin)
        ->test(AdminSettings::class)
        ->assertSet('passwordGeneratorMode', 'button')
        ->set('passwordGeneratorMode', 'prefill')
        ->set('passwordGeneratorType', 'characters')
        ->set('passwordLength', 24)
        ->set('passwordCharacterSets', ['numbers', 'symbols'])
        ->set('passwordAvoidAmbiguous', false)
        ->call('saveSettings')
        ->assertHasNoErrors();

    expect(Setting::get('password_generator_mode'))->toBe('prefill');
    expect(Setting::get('password_generator_type'))->toBe('characters');
    expect(Setting::get('password_generator_length'))->toBe('24');
    expect(Setting::get('password_generator_character_sets'))->toBe('numbers,symbols');
    expect(Setting::get('password_generator_avoid_ambiguous'))->toBe('0');

    Livewire::actingAs($admin)
        ->test(AdminSettings::class)
        ->assertSet('passwordGeneratorMode', 'prefill')
        ->assertSet('passwordLength', 24)
        ->assertSet('passwordCharacterSets', ['numbers', 'symbols'])
        ->assertSet('passwordAvoidAmbiguous', false);
});

test('a passphrase generator saves its words and separator and ignores the hidden character fields', function () {
    $admin = User::query()->where('is_admin', true)->first();

    Livewire::actingAs($admin)
        ->test(AdminSettings::class)
        ->set('passwordGeneratorType', 'passphrase')
        ->set('passphraseWords', 8)
        ->set('passphraseSeparator', 'space')
        ->set('passwordLength', 3)
        ->set('passwordCharacterSets', [])
        ->call('saveSettings')
        ->assertHasNoErrors();

    expect(Setting::get('password_generator_type'))->toBe('passphrase');
    expect(Setting::get('password_generator_words'))->toBe('8');
    expect(Setting::get('password_generator_separator'))->toBe('space');
    expect(Setting::get('password_generator_length'))->toBeNull();
    expect(Setting::get('password_generator_character_sets'))->toBeNull();
});

test('a password generator without any kind of character is refused', function () {
    $admin = User::query()->where('is_admin', true)->first();

    Livewire::actingAs($admin)
        ->test(AdminSettings::class)
        ->set('passwordCharacterSets', [])
        ->call('saveSettings')
        ->assertHasErrors(['passwordCharacterSets' => 'Choose at least one kind of character.']);

    expect(Setting::get('password_generator_character_sets'))->toBeNull();
});

test('password generator settings out of range are refused', function (string $property, mixed $value, string $rule) {
    $admin = User::query()->where('is_admin', true)->first();

    Livewire::actingAs($admin)
        ->test(AdminSettings::class)
        ->set('passwordGeneratorType', $property === 'passphraseWords' ? 'passphrase' : 'characters')
        ->set($property, $value)
        ->call('saveSettings')
        ->assertHasErrors([$property => $rule]);

    expect(Setting::get('password_generator_mode'))->toBeNull();
})->with([
    'an unknown mode' => ['passwordGeneratorMode', 'sometimes', 'in'],
    'a length below 12' => ['passwordLength', 8, 'min'],
    'a length above 64' => ['passwordLength', 65, 'max'],
    'fewer than 4 words' => ['passphraseWords', 3, 'min'],
]);

test('the password example follows the unsaved form and disappears while the form is invalid', function () {
    $admin = User::query()->where('is_admin', true)->first();

    Livewire::actingAs($admin)
        ->test(AdminSettings::class)
        ->set('passwordGeneratorType', 'passphrase')
        ->set('passphraseWords', 5)
        ->set('passphraseSeparator', 'dot')
        ->assertViewHas('passwordExample', fn (string $example): bool => count(explode('.', $example)) === 5)
        ->assertViewHas('passwordEntropy', 64)
        ->set('passphraseWords', 2)
        ->assertViewHas('passwordExample', null)
        ->assertDontSeeHtml('data-test="password-example"');
});

test('switching the password generator off hides its options', function () {
    $admin = User::query()->where('is_admin', true)->first();

    Livewire::actingAs($admin)
        ->test(AdminSettings::class)
        ->assertSeeHtml('wire:model.live="passwordGeneratorType"')
        ->set('passwordGeneratorMode', 'off')
        ->assertDontSeeHtml('wire:model.live="passwordGeneratorType"')
        ->assertDontSeeHtml('data-test="password-example"');
});

test('a max file size far above PHP\'s upload limit loads and saves unchanged', function () {
    $admin = User::query()->where('is_admin', true)->first();
    Setting::set('max_file_size', 15000 * 1024 * 1024);

    Livewire::actingAs($admin)
        ->test(AdminSettings::class)
        ->assertSet('maxFileSize', 15000)
        ->call('saveSettings')
        ->assertHasNoErrors();

    expect(Setting::get('max_file_size'))->toBe((string) (15000 * 1024 * 1024));
});