<?php

declare(strict_types=1);

namespace App\Tests\Unit\Administration\Application\Command\BlockUser;

use App\Administration\Application\Command\BlockUser\BlockUserCommand;
use App\Administration\Application\Command\BlockUser\BlockUserHandler;
use App\Administration\Domain\Exception\UserNotFoundException;
use App\Administration\Domain\Exception\UtilisateurNonBlocableException;
use App\Administration\Domain\Model\User\Email;
use App\Administration\Domain\Model\User\Role;
use App\Administration\Domain\Model\User\StatutCompte;
use App\Administration\Domain\Model\User\User;
use App\Administration\Domain\Model\User\UserId;
use App\Administration\Domain\Policy\ConsentementParentalPolicy;
use App\Administration\Infrastructure\Persistence\InMemory\InMemoryUserRepository;
use App\Shared\Domain\Clock;
use App\Shared\Domain\Tenant\TenantId;
use DateTimeImmutable;
use PHPUnit\Framework\Attributes\Test;
use PHPUnit\Framework\TestCase;

final class BlockUserHandlerTest extends TestCase
{
    private const string TENANT_ID = '550e8400-e29b-41d4-a716-446655440002';

    private InMemoryUserRepository $userRepository;
    private Clock $clock;
    private BlockUserHandler $handler;

    protected function setUp(): void
    {
        $this->userRepository = new InMemoryUserRepository();
        $this->clock = new class implements Clock {
            public function now(): DateTimeImmutable
            {
                return new DateTimeImmutable('2026-02-10 15:00:00');
            }
        };
        $this->handler = new BlockUserHandler($this->userRepository, $this->clock);
    }

    #[Test]
    public function blocksUserSuccessfully(): void
    {
        $user = User::inviter(
            email: new Email('teacher@example.com'),
            role: Role::PROF,
            tenantId: TenantId::fromString(self::TENANT_ID),
            schoolName: 'École Alpha',
            firstName: 'Jean',
            lastName: 'Dupont',
            invitedAt: new DateTimeImmutable('2026-02-01 10:00:00'),
        );
        $user->activer(
            '$argon2id$hashed',
            new DateTimeImmutable('2026-02-02 10:00:00'),
            new ConsentementParentalPolicy($this->clock),
        );
        $this->userRepository->save($user);

        $command = new BlockUserCommand(
            userId: (string) $user->id,
            reason: 'Comportement inapproprié',
        );

        ($this->handler)($command);

        $updated = $this->userRepository->get($user->id);
        self::assertSame(StatutCompte::SUSPENDU, $updated->statut);
        self::assertSame('Comportement inapproprié', $updated->blockedReason);
        self::assertNotNull($updated->blockedAt);
    }

    #[Test]
    public function throwsWhenUserAlreadySuspendu(): void
    {
        $user = User::inviter(
            email: new Email('teacher@example.com'),
            role: Role::PROF,
            tenantId: TenantId::fromString(self::TENANT_ID),
            schoolName: 'École Alpha',
            firstName: 'Jean',
            lastName: 'Dupont',
            invitedAt: new DateTimeImmutable('2026-02-01 10:00:00'),
        );
        $user->activer(
            '$argon2id$hashed',
            new DateTimeImmutable('2026-02-02 10:00:00'),
            new ConsentementParentalPolicy($this->clock),
        );
        $user->bloquer('Première raison', new DateTimeImmutable('2026-02-08 10:00:00'));
        $this->userRepository->save($user);

        $this->expectException(UtilisateurNonBlocableException::class);

        ($this->handler)(new BlockUserCommand(
            userId: (string) $user->id,
            reason: 'Seconde raison',
        ));
    }

    #[Test]
    public function throwsWhenUserNotFound(): void
    {
        $this->expectException(UserNotFoundException::class);

        ($this->handler)(new BlockUserCommand(
            userId: (string) UserId::generate(),
            reason: 'Raison',
        ));
    }
}