<?php

namespace Tests\Feature\User;

use App\Models\Permission;
use App\Models\Province;
use App\Models\Role;
use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Foundation\Testing\WithFaker;
use Illuminate\Http\UploadedFile;
use Tests\TestCase;

class StoreTest extends TestCase
{
    use refreshDatabase, WithFaker;

    public function test_unauthenticated_user_cannot_access(): void
    {
        $response = $this->getJson(route('users.store'));

        $response->assertUnauthorized();
    }
    public function test_user_without_permission_cannot_see_index(): void
    {
        $user = User::factory()->create();
        $response = $this->actingAs($user)->getJson(route('users.store'));
        $response->assertForbidden();
    }

    public function test_fields_are_required()
    {
        $user = User::factory()
            ->has(Permission::factory([
                'name' => 'manage_users',
                'name_fa' => 'مدیریت کاربران'
            ]))
            ->create();

        $response = $this->actingAs($user)->postJson(route('users.store'),[]);
        $response->assertUnprocessable()
            ->assertInValid([
                'full_name' => __('validation.required', ['attribute' => 'نام کامل']),
                'username' => __('validation.required', ['attribute' => 'نام کاربری']),
                'position' => __('validation.required', ['attribute' => 'سمت']),
                'gender' => __('validation.required', ['attribute' => 'جنسیت']),
                'national_id' => __('validation.required', ['attribute' => 'کدملی']),
                'phone_number' => __('validation.required', ['attribute' => 'شماره تلفن']),
                'province_id' => __('validation.required', ['attribute' => 'استان']),
                'password' => __('validation.required', ['attribute' => 'رمز عبور']),
                'role_id' => __('validation.required', ['attribute' => 'شناسه نقش ']),
            ]);

    }
    public function test_gender_should_be_male_or_female()
    {
        $user = User::factory()
        ->has(Permission::factory([
            'name' => 'manage_users',
            'name_fa' => 'مدیریت کاربران'
        ]))
        ->create();

        $response = $this->actingAs($user)->postJson(route('users.store'), [
            'full_name' => $this->faker->name,
            'username' => $this->faker->unique()->userName,
            'position' => $this->faker->jobTitle,
            'gender' => 'other',
            'national_id' => $this->faker->numerify('##########'),
            'phone_number' => $this->faker->numerify('09#########'),
            'province_id' => Province::factory()->create()->id,
            'role_id' => Role::factory()->create()->id,
            'password' => $this->faker->regexify('[A-Za-z]{4}[0-9]{4}')
        ]);

        $response->assertUnprocessable()
            ->assertInvalid([
                'gender' => __('validation.in', ['attribute' => 'جنسیت'])
            ]);
    }

    public function test_phone_number_should_match_regex()
    {
        $user = User::factory()
            ->has(Permission::factory([
                'name' => 'manage_users',
                'name_fa' => 'مدیریت کاربران'
            ]))
            ->create();

        $response = $this->actingAs($user)->postJson(route('users.store'), [
            'full_name' => $this->faker->text,
            'username' => $this->faker->text,
            'position' => $this->faker->text,
            'gender' => $this->faker->randomElement(['female', 'male']),
            'national_id' => $this->faker->numberBetween(1000000000, 9999999999),
            'phone_number' => '01' . $this->faker->numberBetween(100000000, 999999999),
        ]);

        $response->assertUnprocessable()
            ->assertInvalid([
                'phone_number' => __('validation.regex', ['attribute' => 'شماره تلفن'])
            ]);
        }

    public function test_password_should_match_the_regex()
    {
        $user = User::factory()
            ->has(Permission::factory([
                'name' => 'manage_users',
                'name_fa' => 'مدیریت کاربران'
            ]))
            ->create();

        $response = $this->actingAs($user)->postJson(route('users.store'), [
            'full_name' => $this->faker->text,
            'username' => $this->faker->text,
            'position' => $this->faker->text,
            'gender' => $this->faker->randomElement(['female', 'male']),
            'national_id' => $this->faker->numberBetween(1000000000, 9999999999),
            'phone_number' => '09' . $this->faker->numberBetween(100000000, 999999999),
            'province_id' => Province::factory()->create()->id,
            'password' => $this->faker->lexify('?????'),
        ]);

        $response->assertUnprocessable()
            ->assertInvalid([
                'password' => __('validation.regex', ['attribute' => 'رمز عبور'])
            ]);
    }
    public function test_fields_should_be_string()
    {
        $user = User::factory()
            ->has(Permission::factory([
                'name' => 'manage_users',
                'name_fa' => 'مدیریت کاربران'
            ]))
            ->create();

        $response = $this->actingAs($user)->postJson(route('users.store'), [
            'full_name' => $this->faker->numberBetween(10, 20),
            'username' => $this->faker->numberBetween(10, 20),
        ]);

        $response->assertUnprocessable()
            ->assertInvalid([
                'full_name' => __('validation.string', ['attribute' => 'نام کامل']),
                'username' => __('validation.string', ['attribute' => 'نام کاربری']),
            ]);
    }
    public function test_avatar_should_be_less_than_2048()
    {
        $avatar = UploadedFile::fake()->image('file.png')->size('3000');

        $user = User::factory()
            ->has(Permission::factory([
                'name' => 'manage_users',
                'name_fa' => 'مدیریت کاربران'
            ]))
            ->create();

        $response = $this->actingAs($user)->postJson(route('users.store'), [
            'full_name' => $this->faker->text,
            'username' => $this->faker->text,
            'position' => $this->faker->text,
            'gender' => $this->faker->randomElement(['female', 'male']),
            'national_id' => $this->faker->numberBetween(1000000000, 9999999999),
            'phone_number' => '09' . $this->faker->numberBetween(100000000, 999999999),
            'province_id' => Province::factory()->create()->id,
            'password' => $this->faker->numberBetween(1000, 9999) . $this->faker->lexify('?????'),
            'roles' => Role::factory()->create()->id,
            'avatar' => $avatar
        ]);

        $response->assertUnprocessable()
            ->assertInvalid([
                'avatar' => __('validation.max.file', ['attribute' => 'آواتار', 'max' => 2048])
            ]);
    }

    public function test_full_name_must_not_exceed_max_length():void
    {
        $user = User::factory()
            ->has(Permission::factory([
                'name' => 'manage_users',
                'name_fa' => 'مدیریت کاربران'
            ]))
            ->create();
        $longString = $this->faker->regexify('[a-zA-Z0-9]{256}');

        $response = $this->actingAs($user)->postJson(route('users.store'), [
            'full_name' =>  $longString,
            'username' => $this->faker->text,
            'position' => $this->faker->text,
            'gender' => $this->faker->randomElement(['female', 'male']),
            'national_id' => $this->faker->numberBetween(1000000000, 9999999999),
            'phone_number' => '09' . $this->faker->numberBetween(100000000, 999999999),
            'province_id' => Province::factory()->create()->id,
            'password' => $this->faker->numberBetween(1000, 9999) . $this->faker->lexify('?????'),
            'role_id' => Role::factory()->create()->id,

        ]);
        $response->assertUnprocessable()
            ->assertInvalid([
                'full_name' => __('validation.max.string', ['attribute' => 'نام کامل', 'max' => 255]),
            ]);
    }

    public function test_fields_id_should_be_unique()
    {
        $user = User::factory()
            ->has(Permission::factory([
                'name' => 'manage_users',
                'name_fa' => 'مدیریت کاربران'
            ]))
            ->create();
        $existingPhone = '09' .$this->faker->numberBetween(100000000, 999999999);
        $existingEmail = $this->faker->email;
        $existingUser = $this->faker->name;
        $existingNational = $this->faker->numberBetween(1000000000, 9999999999);

        User::factory()->create([
            'phone_number' => $existingPhone,
            'national_id' => $existingNational,
            'username' => $existingUser,
            'email' => $existingEmail,
        ]);

        $response = $this->actingAs($user)->postJson(route('users.store'), [
            'full_name' => $this->faker->text,
            'username' =>$existingUser,
            'position' => $this->faker->text,
            'gender' => $this->faker->randomElement(['female', 'male']),
            'national_id' =>$existingNational,
            'phone_number' => $existingPhone,
            'province_id' => Province::factory()->create()->id,
            'password' => $this->faker->numberBetween(1000, 9999) . $this->faker->lexify('?????'),
            'role_id' => Role::factory()->create()->id,
            'email' =>$existingEmail,
        ]);

        $response->assertJsonValidationErrors([
                'phone_number' => __('validation.unique', ['attribute' => 'شماره تلفن']),
                'email' => __('validation.unique', ['attribute' => 'ایمیل']),
                'username' => __('validation.unique', ['attribute' => 'نام کاربری']),
                'national_id' => __('validation.unique', ['attribute' => 'کدملی']),
            ]);
    }

    public function test_password_should_have_minimum_8_characters(): void
    {
        $user = User::factory()
            ->has(Permission::factory([
                'name' => 'manage_users',
                'name_fa' => 'مدیریت کاربران'
            ]))
            ->create();

        $response = $this->actingAs($user)->postJson(route('users.store'), [
            'full_name' => $this->faker->name,
            'username' => $this->faker->unique()->userName,
            'position' => $this->faker->jobTitle,
            'gender' => $this->faker->randomElement(['male', 'female']),
            'national_id' => $this->faker->numerify('##########'),
            'phone_number' => $this->faker->numerify('09#########'),
            'province_id' => Province::factory()->create()->id,
            'password' => 'abc123',
            'role_id' => Role::factory()->create()->id,
            'email' => $this->faker->unique()->safeEmail,
        ]);

        $response->assertUnprocessable()
            ->assertInvalid([
                'password' => __('validation.min.string', ['attribute' => 'رمز عبور', 'min' => 8]),
            ]);
    }
    public function test_national_id_should_be_10_digits()
    {
        $user = User::factory()
            ->has(Permission::factory([
                'name' => 'manage_users',
                'name_fa' => 'مدیریت کاربران'
            ]))
            ->create();

        $response = $this->actingAs($user)->postJson(route('users.store'), [
            'full_name' => $this->faker->text,
            'username' => $this->faker->text,
            'position' => $this->faker->text,
            'gender' => $this->faker->randomElement(['female', 'male']),
            'national_id' => $this->faker->numberBetween(10000, 99999),
        ]);

        $response->assertUnprocessable()
            ->assertInvalid([
                'national_id' => __('validation.digits', [
                    'attribute' => 'کدملی',
                    'digits' => 10,
                ])
            ]);
    }
    public function test_phone_number_should_be_11_digits()
    {
        $user = User::factory()
            ->has(Permission::factory([
                'name' => 'manage_users',
                'name_fa' => 'مدیریت کاربران'
            ]))
            ->create();

        $response = $this->actingAs($user)->postJson(route('users.store'), [
            'full_name' => $this->faker->text,
            'username' => $this->faker->text,
            'position' => $this->faker->text,
            'gender' => $this->faker->randomElement(['female', 'male']),
            'national_id' => $this->faker->numberBetween(1000000000, 9999999999),
            'phone_number' => '09' . $this->faker->numberBetween(1000000, 9999999),
        ]);

        $response->assertUnprocessable()
            ->assertInvalid([
                'phone_number' => __('validation.digits', [
                    'attribute' => 'شماره تلفن',
                    'digits' => 11
                ])
            ]);
    }

    public function test_role_should_exist_in_roles_table()
    {
        $user = User::factory()
            ->has(Permission::factory([
                'name' => 'manage_users',
                'name_fa' => 'مدیریت کاربران'
            ]))
            ->create();
        $invalidRoleId = 9999;

        $response = $this->actingAs($user)->postJson(route('users.store'), [
            'full_name' => $this->faker->text,
            'username' => $this->faker->text,
            'position' => $this->faker->text,
            'gender' => $this->faker->randomElement(['female', 'male']),
            'national_id' => $this->faker->numberBetween(1000000000, 9999999999),
            'phone_number' => '09' . $this->faker->numberBetween(100000000, 999999999),
            'province_id' => Province::factory()->create()->id,
            'password' => $this->faker->numberBetween(1000, 9999) . $this->faker->lexify('?????'),
            'role_id' => $invalidRoleId ,
        ]);

        $response->assertUnprocessable()
            ->assertInvalid([
                'role_id' => __('validation.exists', ['attribute' => 'شناسه نقش '])
            ]);
    }
    public function test_province_id_should_be_exist_in_province_table()
    {
        $user = User::factory()
            ->has(Permission::factory([
                'name' => 'manage_users',
                'name_fa' => 'مدیریت کاربران'
            ]))
            ->create();
        $invalidProvince =  $this->faker->numberBetween(100000000, 999999999);

        $response = $this->actingAs($user)->postJson(route('users.store'), [            'full_name' => $this->faker->text,
            'username' => $this->faker->text,
            'position' => $this->faker->text,
            'gender' => $this->faker->randomElement(['female', 'male']),
            'national_id' => $this->faker->numberBetween(1000000000, 9999999999),
            'phone_number' => '09' . $this->faker->numberBetween(100000000, 999999999),
            'province_id' => $invalidProvince,
        ]);

        $response->assertUnprocessable()
            ->assertInvalid([
                'province_id' => __('validation.exists', ['attribute' => 'استان'])
            ]);
    }

    public function test_email_should_have_valid_format(): void
    {
        $user = User::factory()
            ->has(Permission::factory([
                'name' => 'manage_users',
                'name_fa' => 'مدیریت کاربران'
            ]))
            ->create();

        $response = $this->actingAs($user)->postJson(route('users.store'), [
            'full_name' => $this->faker->name,
            'username' => $this->faker->unique()->userName,
            'position' => $this->faker->jobTitle,
            'gender' => $this->faker->randomElement(['male', 'female']),
            'national_id' => $this->faker->numerify('##########'),
            'phone_number' => $this->faker->numerify('09#########'),
            'province_id' => Province::factory()->create()->id,
            'password' => 'abc12345',
            'role_id' => Role::factory()->create()->id,
            'email' => 'not-an-email',
        ]);

        $response->assertUnprocessable()
            ->assertInvalid([
                'email' => __('validation.email', ['attribute' => 'ایمیل']),
            ]);
    }
    public function test_avatar_should_be_valid_mime_type(): void
    {
        $user = User::factory()
            ->has(Permission::factory([
                'name' => 'manage_users',
                'name_fa' => 'مدیریت کاربران'
            ]))
            ->create();

        $invalidFile = UploadedFile::fake()->create('avatar.txt', 100, 'text/plain');

        $response = $this->actingAs($user)->postJson(route('users.store'), [
            'full_name' => $this->faker->name,
            'username' => $this->faker->unique()->userName,
            'position' => $this->faker->jobTitle,
            'gender' => $this->faker->randomElement(['male', 'female']),
            'national_id' => $this->faker->numerify('##########'),
            'phone_number' => $this->faker->numerify('09#########'),
            'province_id' => Province::factory()->create()->id,
            'password' => $this->faker->regexify('[A-Za-z]{4}[0-9]{4}'),
            'role_id' => Role::factory()->create()->id,
            'email' => $this->faker->unique()->safeEmail,
            'avatar' => $invalidFile,
        ]);

        $response->assertUnprocessable()
            ->assertInvalid([
                'avatar' => __('validation.mimes', ['attribute' => 'آواتار', 'values' => 'png, jpg, pdf']),
            ]);
    }
    public function test_phone_number_must_be_numeric(): void
    {
        $user = User::factory()
            ->has(Permission::factory([
                'name' => 'manage_users',
                'name_fa' => 'مدیریت کاربران'
            ]))
            ->create();
        $invalidPhone =  $this->faker->word();

        $response = $this->actingAs($user)->postJson(route('users.store'), [
            'full_name' => $this->faker->name,
            'username' => $this->faker->unique()->userName,
            'position' => $this->faker->jobTitle,
            'gender' => $this->faker->randomElement(['male', 'female']),
            'national_id' => $this->faker->numerify('##########'),
            'phone_number' =>$invalidPhone ,
            'province_id' => Province::factory()->create()->id,
            'password' => 'abc12345',
            'role_id' => Role::factory()->create()->id,
            'email' => 'not-an-email',
        ]);

        $response->assertUnprocessable()
            ->assertInvalid([
                'phone_number' => __('validation.numeric', ['attribute' => 'شماره تلفن']),
            ]);

    }


    public function test_can_store_an_user()
    {
        $user = User::factory()
            ->has(Permission::factory([
                'name' => 'manage_users',
                'name_fa' => 'مدیریت کاربران'
            ]))
            ->create();
        $username = $this->faker->userName;


        $response = $this->actingAs($user)->postJson(route('users.store'), [
            'full_name' => $this->faker->name,
            'username' => $username,
            'position' => $this->faker->lexify('?????'),
            'gender' => $this->faker->randomElement(['female', 'male']),
            'national_id' => $this->faker->numberBetween(1000000000, 9999999999),
            'phone_number' => '09' . $this->faker->numberBetween(100000000, 999999999),
            'province_id' => Province::factory()->create()->id,
            'password' => $this->faker->numberBetween(1000, 9999) . $this->faker->lexify('?????'),
            'role_id' => Role::factory()->create()->id,
            'telephone_id' => '01-1'
        ]);

        $response->assertStatus(200)
            ->assertExactJson([
                'message' => __('messages.successful')
            ]);

        $this->assertDatabaseHas('users', [
            'username' =>  $username
        ]);
    }


}