<?php

declare(strict_types=1);

namespace App\Tests\Unit\Scolarite\Application\Command\CreateEvaluation;

use App\Administration\Domain\Model\SchoolClass\ClassId;
use App\Administration\Domain\Model\Subject\SubjectId;
use App\Administration\Domain\Model\User\UserId;
use App\Scolarite\Application\Command\CreateEvaluation\CreateEvaluationCommand;
use App\Scolarite\Application\Command\CreateEvaluation\CreateEvaluationHandler;
use App\Scolarite\Application\Port\EnseignantAffectationChecker;
use App\Scolarite\Domain\Exception\BaremeInvalideException;
use App\Scolarite\Domain\Exception\CoefficientInvalideException;
use App\Scolarite\Domain\Exception\EnseignantNonAffecteException;
use App\Scolarite\Domain\Model\Evaluation\EvaluationId;
use App\Scolarite\Domain\Model\Evaluation\EvaluationStatus;
use App\Scolarite\Infrastructure\Persistence\InMemory\InMemoryEvaluationRepository;
use App\Shared\Domain\Clock;
use App\Shared\Domain\Tenant\TenantId;
use DateTimeImmutable;
use PHPUnit\Framework\Attributes\Test;
use PHPUnit\Framework\TestCase;

final class CreateEvaluationHandlerTest extends TestCase
{
    private const string TENANT_ID = '550e8400-e29b-41d4-a716-446655440001';
    private const string CLASS_ID = '550e8400-e29b-41d4-a716-446655440020';
    private const string SUBJECT_ID = '550e8400-e29b-41d4-a716-446655440030';
    private const string TEACHER_ID = '550e8400-e29b-41d4-a716-446655440010';

    private InMemoryEvaluationRepository $evaluationRepository;
    private Clock $clock;

    protected function setUp(): void
    {
        $this->evaluationRepository = new InMemoryEvaluationRepository();
        $this->clock = new class implements Clock {
            public function now(): DateTimeImmutable
            {
                return new DateTimeImmutable('2026-03-12 10:00:00');
            }
        };
    }

    #[Test]
    public function itCreatesEvaluationSuccessfully(): void
    {
        $handler = $this->createHandler(affecte: true);
        $command = $this->createCommand();

        $evaluation = $handler($command);

        self::assertNotEmpty((string) $evaluation->id);
        self::assertSame(EvaluationStatus::PUBLISHED, $evaluation->status);
        self::assertSame('Contrôle chapitre 5', $evaluation->title);
        self::assertSame(20, $evaluation->gradeScale->maxValue);
        self::assertSame(1.0, $evaluation->coefficient->value);
    }

    #[Test]
    public function itPersistsEvaluationInRepository(): void
    {
        $handler = $this->createHandler(affecte: true);
        $command = $this->createCommand();

        $created = $handler($command);

        $evaluation = $this->evaluationRepository->get(
            EvaluationId::fromString((string) $created->id),
            TenantId::fromString(self::TENANT_ID),
        );

        self::assertSame('Contrôle chapitre 5', $evaluation->title);
    }

    #[Test]
    public function itThrowsWhenTeacherNotAffected(): void
    {
        $handler = $this->createHandler(affecte: false);

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

        $handler($this->createCommand());
    }

    #[Test]
    public function itCreatesEvaluationWithCustomGradeScale(): void
    {
        $handler = $this->createHandler(affecte: true);
        $command = $this->createCommand(gradeScale: 10);

        $evaluation = $handler($command);

        self::assertSame(10, $evaluation->gradeScale->maxValue);
    }

    #[Test]
    public function itCreatesEvaluationWithCustomCoefficient(): void
    {
        $handler = $this->createHandler(affecte: true);
        $command = $this->createCommand(coefficient: 2.5);

        $evaluation = $handler($command);

        self::assertSame(2.5, $evaluation->coefficient->value);
    }

    #[Test]
    public function itThrowsWhenGradeScaleIsInvalid(): void
    {
        $handler = $this->createHandler(affecte: true);

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

        $handler($this->createCommand(gradeScale: 0));
    }

    #[Test]
    public function itThrowsWhenCoefficientIsInvalid(): void
    {
        $handler = $this->createHandler(affecte: true);

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

        $handler($this->createCommand(coefficient: 0.0));
    }

    #[Test]
    public function itAllowsNullDescription(): void
    {
        $handler = $this->createHandler(affecte: true);
        $command = $this->createCommand(description: null);

        $evaluation = $handler($command);

        self::assertNull($evaluation->description);
    }

    private function createHandler(bool $affecte): CreateEvaluationHandler
    {
        $affectationChecker = new class($affecte) implements EnseignantAffectationChecker {
            public function __construct(private readonly bool $affecte)
            {
            }

            public function estAffecte(UserId $teacherId, ClassId $classId, SubjectId $subjectId, TenantId $tenantId): bool
            {
                return $this->affecte;
            }
        };

        return new CreateEvaluationHandler(
            $this->evaluationRepository,
            $affectationChecker,
            $this->clock,
        );
    }

    private function createCommand(
        ?string $description = 'Évaluation sur les fonctions',
        int $gradeScale = 20,
        float $coefficient = 1.0,
    ): CreateEvaluationCommand {
        return new CreateEvaluationCommand(
            tenantId: self::TENANT_ID,
            classId: self::CLASS_ID,
            subjectId: self::SUBJECT_ID,
            teacherId: self::TEACHER_ID,
            title: 'Contrôle chapitre 5',
            description: $description,
            evaluationDate: '2026-04-15',
            gradeScale: $gradeScale,
            coefficient: $coefficient,
        );
    }
}