<?php

namespace Tests\Feature;

use App\Enums\ApprovalStatusEnum;
use App\Enums\IdentityVerificationStatusEnum;
use App\Enums\UserTypeEnum;
use App\Models\IdentityVerification;
use App\Models\Provider;
use App\Models\User;
use App\Services\Didit\DiditSessionService;
use App\Services\PushNotificationService;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Facades\Mail;
use Mockery\MockInterface;
use Tests\TestCase;

class DiditMaintenanceTest extends TestCase
{
    use RefreshDatabase;

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

        Mail::fake();
        $this->mock(PushNotificationService::class)->shouldReceive('sendToUser')->andReturnNull();
    }

    public function test_sync_reconcilia_verificacao_travada(): void
    {
        $provider     = $this->makeProvider();
        $verification = $this->makeStuckVerification($provider->user_id);

        $this->mockDecision($verification->session_id, $this->approvedDecision());

        $this->artisan('didit:sync')->assertSuccessful();

        $verification->refresh();

        $this->assertSame('Approved', $verification->didit_status);
        $this->assertNotNull($verification->completed_at);
        $this->assertSame(
            IdentityVerificationStatusEnum::APPROVED,
            $provider->refresh()->identity_verification_status,
        );
    }

    public function test_sync_ignora_verificacao_recente(): void
    {
        $provider = $this->makeProvider();

        $this->makeStuckVerification($provider->user_id, startedHoursAgo: 1);

        $this->mock(DiditSessionService::class)
            ->shouldNotReceive('getDecision');

        $this->artisan('didit:sync')
            ->expectsOutputToContain('Nenhuma verificacao para reconciliar')
            ->assertSuccessful();
    }

    public function test_dry_run_nao_altera_nada(): void
    {
        $provider     = $this->makeProvider();
        $verification = $this->makeStuckVerification($provider->user_id);

        $this->mock(DiditSessionService::class)
            ->shouldNotReceive('getDecision');

        $this->artisan('didit:sync', ['--dry-run' => true])->assertSuccessful();

        $this->assertSame('In Progress', $verification->refresh()->didit_status);
    }

    //

    private function mockDecision(string $sessionId, array $decision): MockInterface
    {
        return $this->mock(DiditSessionService::class, function (MockInterface $mock) use ($sessionId, $decision) {
            $mock->shouldReceive('getDecision')->with($sessionId)->once()->andReturn($decision);
        });
    }

    private function approvedDecision(): array
    {
        $decision = json_decode(
            file_get_contents(base_path('tests/Fixtures/didit/decision_approved_cin.json')),
            true,
        );

        $decision['status'] = 'Approved';

        return $decision;
    }

    private function makeStuckVerification(int $userId, int $startedHoursAgo = 12): IdentityVerification
    {
        return IdentityVerification::query()->create([
            'user_id'      => $userId,
            'session_id'   => (string) \Illuminate\Support\Str::uuid(),
            'didit_status' => 'In Progress',
            'attempt'      => 1,
            'started_at'   => now()->subHours($startedHoursAgo),
        ]);
    }

    private function makeProvider(): Provider
    {
        $user = User::query()->create([
            'name'     => 'Prestador Teste',
            'email'    => 'prestador'.uniqid().'@teste.com',
            'password' => 'secret',
            'type'     => UserTypeEnum::PROVIDER->value,
        ]);

        return Provider::query()->create([
            'user_id'         => $user->id,
            'document'        => '06767310905',
            'birth_date'      => '1990-01-01',
            'approval_status' => ApprovalStatusEnum::PENDING->value,
        ]);
    }
}