<?php

declare(strict_types=1);

namespace App\Tests\Controller\Admin\AccommodationBooking;

use App\Controller\Admin\AccommodationBooking\EditController;
use App\Entity\Groups\AccommodationBooking;
use App\Entity\User;
use App\Enum\Groups\AccommodationBookingStatus;
use App\Repository\Groups\AdditionalServiceRepository;
use App\Repository\Groups\BoardServiceRepository;
use App\Repository\UserRepository;
use App\Service\AccommodationBookingService;
use Doctrine\ORM\EntityManagerInterface;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;
use Psr\Log\LoggerInterface;
use Symfony\Component\Form\FormInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;

/**
 * Covers what editing must NOT do — it never moves the booking on and never mails the
 * customer — plus the Betreuer choices. The transitions themselves belong to the named
 * actions and are tested in AccommodationBookingServiceTest and the action controllers.
 */
class EditControllerTest extends TestCase
{
    #[DataProvider('everyStatus')]
    public function testSavingNeverNotifiesTheCustomer(AccommodationBookingStatus $status): void
    {
        // Sending used to be a side effect of saving a status change, which is how an inquiry
        // that arrived already Offen could never be offered at all. Editing is now inert.
        $bookingService = $this->createMock(AccommodationBookingService::class);
        $bookingService->expects(self::once())->method('refreshPriceSnapshot');
        $bookingService->expects(self::never())->method('issueAccessLink');
        $bookingService->expects(self::never())->method('sendCustomerConfirmationEmail');
        $bookingService->expects(self::never())->method('sendOffer');

        $booking = new AccommodationBooking();
        $booking->setStatus($status);

        $this->submitEdit($booking, $bookingService);

        self::assertSame($status, $booking->getStatus(), 'editing leaves the status where it was');
    }

    /**
     * @return iterable<string, array{AccommodationBookingStatus}>
     */
    public static function everyStatus(): iterable
    {
        foreach (AccommodationBookingStatus::cases() as $status) {
            yield $status->value => [$status];
        }
    }

    private function submitEdit(AccommodationBooking $booking, AccommodationBookingService $bookingService): void
    {
        $form = $this->createStub(FormInterface::class);
        $form->method('handleRequest')->willReturn($form);
        $form->method('isSubmitted')->willReturn(true);
        $form->method('isValid')->willReturn(true);
        $form->method('has')->willReturn(false);

        $entityManager = $this->createMock(EntityManagerInterface::class);
        $entityManager->expects(self::once())->method('flush');

        $controller = new TestableEditController(
            $entityManager,
            $this->createStub(LoggerInterface::class),
            $this->createStub(BoardServiceRepository::class),
            $this->createStub(AdditionalServiceRepository::class),
            $this->createStub(UserRepository::class),
            $bookingService,
            $form,
        );

        $response = $controller->index($booking, Request::create('/admin/accommodation-booking/1/edit', 'POST'));

        self::assertSame(Response::HTTP_FOUND, $response->getStatusCode());
    }

    public function testManagerWithoutAdminRoleGetsNoBetreuerChoices(): void
    {
        $userRepo = $this->createMock(UserRepository::class);
        $userRepo->expects(self::never())->method('findGroupsStaff');

        $controller = $this->buildController($userRepo, granted: false);
        $controller->index(new AccommodationBooking(), Request::create('/admin/accommodation-booking/1/edit'));

        self::assertSame([], $controller->capturedOptions['assignable_managers']);
    }

    public function testAdminGetsTheGroupsStaffAsBetreuerChoices(): void
    {
        $staff = [new User('manager@example.test')];
        $userRepo = $this->createStub(UserRepository::class);
        $userRepo->method('findGroupsStaff')->willReturn($staff);

        $controller = $this->buildController($userRepo, granted: true);
        $controller->index(new AccommodationBooking(), Request::create('/admin/accommodation-booking/1/edit'));

        self::assertSame($staff, $controller->capturedOptions['assignable_managers']);
    }

    public function testAnAssignedUserWhoLostTheRoleStaysSelectable(): void
    {
        $formerManager = new User('former@example.test');
        $staff = [new User('manager@example.test')];

        $userRepo = $this->createStub(UserRepository::class);
        $userRepo->method('findGroupsStaff')->willReturn($staff);

        $booking = new AccommodationBooking();
        $booking->setManagedBy($formerManager);

        $controller = $this->buildController($userRepo, granted: true);
        $controller->index($booking, Request::create('/admin/accommodation-booking/1/edit'));

        self::assertSame([$staff[0], $formerManager], $controller->capturedOptions['assignable_managers']);
    }

    private function buildController(UserRepository $userRepo, bool $granted): TestableEditController
    {
        // An unsubmitted form: index() falls through to render() and only the options
        // handed to createForm() are of interest here.
        $form = $this->createStub(FormInterface::class);
        $form->method('handleRequest')->willReturn($form);
        $form->method('isSubmitted')->willReturn(false);

        return new TestableEditController(
            $this->createStub(EntityManagerInterface::class),
            $this->createStub(LoggerInterface::class),
            $this->createStub(BoardServiceRepository::class),
            $this->createStub(AdditionalServiceRepository::class),
            $userRepo,
            $this->createStub(AccommodationBookingService::class),
            $form,
            $granted,
        );
    }
}

final class TestableEditController extends EditController
{
    /** @var array<string, mixed> */
    public array $capturedOptions = [];

    public function __construct(
        EntityManagerInterface $entityManager,
        LoggerInterface $logger,
        BoardServiceRepository $boardServiceRepo,
        AdditionalServiceRepository $additionalServiceRepo,
        UserRepository $userRepo,
        AccommodationBookingService $bookingService,
        private readonly FormInterface $form,
        private readonly bool $granted = false,
    ) {
        parent::__construct($entityManager, $logger, $boardServiceRepo, $additionalServiceRepo, $userRepo, $bookingService);
    }

    protected function createForm(string $type, mixed $data = null, array $options = []): FormInterface
    {
        $this->capturedOptions = $options;

        return $this->form;
    }

    protected function isGranted(mixed $attribute, mixed $subject = null): bool
    {
        return $this->granted;
    }

    /**
     * @param array<string, mixed> $parameters
     */
    protected function render(string $view, array $parameters = [], ?Response $response = null): Response
    {
        return new Response();
    }

    protected function addFlash(string $type, mixed $message): void
    {
    }

    /**
     * @param array<string, mixed> $parameters
     */
    protected function generateUrl(string $route, array $parameters = [], int $referenceType = 1): string
    {
        return '/'.$route.'?'.http_build_query($parameters);
    }
}