<?php

namespace Tests\Fakes;

use App\Set\CreateSetDto;
use App\Set\Set as DomainSet;
use App\Set\SetRepository;

class FakeSetRepository implements SetRepository
{
    /**
     * @var DomainSet[]
     */
    private array $setsById = [];

    /**
     * @var array<int, int>
     */
    private array $sortOrdersById = [];

    public function create(CreateSetDto $dto): DomainSet
    {
        $id = count($this->setsById) + 1;
        $set = new DomainSet(
            id: $id,
            name: $dto->name,
            description: $dto->description,
            iconImageUrl: $dto->iconImageUrl,
        );
        $this->setsById[$id] = $set;
        $this->sortOrdersById[$id] = $this->nextSortOrder();

        return $set;
    }

    public function update(DomainSet $set): DomainSet
    {
        $updatedSet = $this->cloneSet($set);
        $this->setsById[$updatedSet->getId()] = $updatedSet;

        return $this->cloneSet($updatedSet);
    }

    public function delete(DomainSet $set): void
    {
        unset($this->setsById[$set->getId()]);
        unset($this->sortOrdersById[$set->getId()]);
    }

    public function find(int $id): ?DomainSet
    {
        if (! isset($this->setsById[$id])) {
            return null;
        }

        return $this->cloneSet($this->setsById[$id]);
    }

    /**
     * @return DomainSet[]
     */
    public function getAll(): array
    {
        $sets = [];
        foreach ($this->setsById as $set) {
            $sets[] = $this->cloneSet($set);
        }
        usort($sets, function (
            DomainSet $firstSet,
            DomainSet $secondSet,
        ): int {
            $firstSortOrder = $this->sortOrdersById[$firstSet->getId()]
                ?? $firstSet->getId();
            $secondSortOrder = $this->sortOrdersById[$secondSet->getId()]
                ?? $secondSet->getId();
            if ($firstSortOrder === $secondSortOrder) {
                return $firstSet->getId() <=> $secondSet->getId();
            }

            return $firstSortOrder <=> $secondSortOrder;
        });

        return $sets;
    }

    public function reorder(array $setIds): array
    {
        $sortOrder = 1;
        foreach ($setIds as $setId) {
            $this->sortOrdersById[$setId] = $sortOrder;
            $sortOrder++;
        }

        return $this->getAll();
    }

    private function cloneSet(DomainSet $set): DomainSet
    {
        return new DomainSet(
            id: $set->getId(),
            name: $set->getName(),
            description: $set->getDescription(),
            iconImageUrl: $set->getIconImageUrl(),
        );
    }

    private function nextSortOrder(): int
    {
        if ($this->sortOrdersById === []) {
            return 1;
        }

        return max($this->sortOrdersById) + 1;
    }
}