Attainly/backend/tests/Fakes/FakeElementRepository.php

<?php

namespace Tests\Fakes;

use App\Element\CreateElementDto;
use App\Element\Element;
use App\Element\ElementRepository;
use App\Set\Set;
use DomainException;

class FakeElementRepository implements ElementRepository
{
    /**
     * @var array<int, Element>
     */
    private array $elements = [];

    public function create(CreateElementDto $dto): Element
    {
        $this->validateParentSet($dto);
        $id = count($this->elements) + 1;
        $element = new Element(
            id: $id,
            name: $dto->name,
            level: $dto->level,
            parentElement: $dto->parentElement,
            position: $this->nextPosition($dto),
        );
        $this->elements[$id] = $element;

        return $this->copy($element);
    }

    public function find(int $id): ?Element
    {
        $element = $this->elements[$id] ?? null;

        return $element === null ? null : $this->copy($element);
    }

    public function findBySet(Set $set): array
    {
        $elements = array_filter(
            $this->elements,
            function (Element $element) use ($set): bool {
                return $element->getSet()->getId() === $set->getId();
            },
        );

        return array_map(function (Element $element): Element {
            return $this->copy($element);
        }, array_values($elements));
    }

    public function findTopLevelBySet(Set $set): array
    {
        $elements = array_filter(
            $this->elements,
            function (Element $element) use ($set): bool {
                return $element->getSet()->getId() === $set->getId()
                    && $element->getParentElement() === null;
            },
        );

        return $this->orderedCopies($elements);
    }

    public function findByParentElement(Element $parentElement): array
    {
        $elements = array_filter(
            $this->elements,
            function (Element $element) use ($parentElement): bool {
                return $element->getSet()->getId()
                    === $parentElement->getSet()->getId()
                    && $element->getParentElement()?->getId()
                    === $parentElement->getId();
            },
        );

        return $this->orderedCopies($elements);
    }

    /**
     * @throws DomainException
     */
    private function validateParentSet(CreateElementDto $dto): void
    {
        $parentElement = $dto->parentElement;
        if ($parentElement === null) {
            if ($dto->level->getDepth() !== 0) {
                throw new DomainException(
                    'root element must use the first set level',
                );
            }

            return;
        }

        if (
            $parentElement->getSet()->getId()
            !== $dto->level->getSet()->getId()
        ) {
            throw new DomainException(
                'parent element must belong to the same set',
            );
        }

        if (
            $dto->level->getDepth()
            !== $parentElement->getLevel()->getDepth() + 1
        ) {
            throw new DomainException(
                'child element must use the next set level',
            );
        }
    }

    private function nextPosition(CreateElementDto $dto): int
    {
        $requestedParentId = $dto->parentElement?->getId();
        $maximumPosition = 0;

        foreach ($this->elements as $element) {
            if (
                $element->getSet()->getId()
                !== $dto->level->getSet()->getId()
            ) {
                continue;
            }

            $elementParentId = $element->getParentElement()?->getId();
            if ($elementParentId !== $requestedParentId) {
                continue;
            }

            $maximumPosition = max(
                $maximumPosition,
                $element->getPosition(),
            );
        }

        return $maximumPosition + 1;
    }

    /**
     * @param array<int, Element> $elements
     * @return list<Element>
     */
    private function orderedCopies(array $elements): array
    {
        usort($elements, function (Element $first, Element $second): int {
            $positionComparison = $first->getPosition()
                <=> $second->getPosition();
            if ($positionComparison !== 0) {
                return $positionComparison;
            }

            return $first->getId() <=> $second->getId();
        });

        return array_map(function (Element $element): Element {
            return $this->copy($element);
        }, $elements);
    }

    private function copy(Element $element): Element
    {
        $parentElement = $element->getParentElement();

        return new Element(
            id: $element->getId(),
            name: $element->getName(),
            level: $element->getLevel(),
            parentElement: $parentElement === null
                ? null
                : $this->copy($parentElement),
            position: $element->getPosition(),
        );
    }
}