Stu\Component\StarSystem\StarSystemCreation

Complexity

Total Complexity

21

Size/Duplication

Total Lines	167
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	2
Bugs	1	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	17	1
A	getMassCenterFields()	0	11	2
A	createSystemMapEntries()	0	11	3
A	initializeStarSystem()	0	15	1
B	recreateStarSystem()	0	39	7
A	getFieldType()	0	12	4
A	createSystemMap()	0	11	1
A	getStarSystem()	0	13	2

<?php

declare(strict_types=1);

namespace Stu\Component\StarSystem;

use RuntimeException;
use Stu\Module\Control\StuRandom;
use Stu\Module\Logging\LoggerEnum;
use Stu\Module\Logging\LoggerUtilFactoryInterface;
use Stu\Module\Logging\LoggerUtilInterface;
use Stu\Orm\Entity\MapFieldTypeInterface;
use Stu\Orm\Entity\MapInterface;
use Stu\Orm\Entity\MassCenterTypeInterface;
use Stu\Orm\Entity\StarSystemInterface;
use Stu\Orm\Entity\StarSystemTypeInterface;
use Stu\Orm\Repository\MapFieldTypeRepositoryInterface;
use Stu\Orm\Repository\MapRepositoryInterface;
use Stu\Orm\Repository\StarSystemMapRepositoryInterface;
use Stu\Orm\Repository\StarSystemRepositoryInterface;
use Stu\StarsystemGenerator\StarsystemGeneratorInterface;
use Stu\StarsystemGenerator\SystemMapDataInterface;

//TODO unit tests
final class StarSystemCreation implements StarSystemCreationInterface
{
    private StarSystemRepositoryInterface $starSystemRepository;

    private MapRepositoryInterface $mapRepository;

    private StarSystemMapRepositoryInterface $starSystemMapRepository;

    private MapFieldTypeRepositoryInterface $mapFieldTypeRepository;

    private StarsystemGeneratorInterface $starsystemGenerator;

    private StuRandom $stuRandom;

    private LoggerUtilInterface $loggerUtil;

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

    public function __construct(
        StarSystemRepositoryInterface $starSystemRepository,
        MapRepositoryInterface $mapRepository,
        StarSystemMapRepositoryInterface $starSystemMapRepository,
        MapFieldTypeRepositoryInterface $mapFieldTypeRepository,
        StarsystemGeneratorInterface $starsystemGenerator,
        StuRandom $stuRandom,
        LoggerUtilFactoryInterface $loggerUtilFactory
    ) {
        $this->starSystemRepository = $starSystemRepository;
        $this->mapRepository = $mapRepository;
        $this->starSystemMapRepository = $starSystemMapRepository;
        $this->mapFieldTypeRepository = $mapFieldTypeRepository;
        $this->starsystemGenerator = $starsystemGenerator;
        $this->stuRandom = $stuRandom;

        $this->loggerUtil = $loggerUtilFactory->getLoggerUtil();
    }

    public function recreateStarSystem(MapInterface $map, string $randomSystemName): ?StarSystemInterface
    {
        $this->loggerUtil->init('SysGen', LoggerEnum::LEVEL_ERROR);

        $this->loggerUtil->log(sprintf('recreating for map: %s', $map->getSectorString()));

        $systemType = $map->getStarSystemType();

        if ($systemType === null) {
            throw new RuntimeException(sprintf('no system type configured on mapId %d', $map->getId()));
        }

        $this->loggerUtil->log(sprintf('systemType: %d, isGenerateable: %s', $systemType->getId(), $systemType->getIsGenerateable() ? 'true' : 'false'));

        if (
            $systemType->getIsGenerateable() === null
            || $systemType->getIsGenerateable() === false
        ) {
            return null;
        }

        $firstMassCenterType = $systemType->getFirstMassCenterType();
        $secondMassCenterType = $systemType->getSecondMassCenterType();

        if ($firstMassCenterType === null) {
            throw new RuntimeException(sprintf('first mass center is null, systemTypeId %d', $systemType->getId()));
        }

        $systemMapData = $this->starsystemGenerator->generate(
            $systemType->getId(),
            $this->getMassCenterFields($firstMassCenterType),
            $secondMassCenterType === null ? null : $this->getMassCenterFields($secondMassCenterType)
        );

        $starSystem = $this->getStarSystem($map);
        $this->initializeStarSystem($systemType, $map, $starSystem, $systemMapData, $randomSystemName);
        $this->starSystemRepository->save($starSystem);

        return $starSystem;
    }

    private function initializeStarSystem(
        StarSystemTypeInterface $systemType,
        MapInterface $map,
        StarSystemInterface $starSystem,
        SystemMapDataInterface $mapData,
        string $randomSystemName
    ): void {
        $starSystem->setCx($map->getCx());
        $starSystem->setCy($map->getCy());
        $starSystem->setType($systemType);
        $starSystem->setName($randomSystemName);
        $starSystem->setMaxX($mapData->getWidth());
        $starSystem->setMaxY($mapData->getHeight());
        $starSystem->setBonusFieldAmount($this->stuRandom->rand(0, 3, true, 2));
        $this->createSystemMapEntries($starSystem, $mapData);
    }

    private function createSystemMapEntries(
        StarSystemInterface $starSystem,
        SystemMapDataInterface $mapData
    ): void {
        $fieldData = $mapData->getFieldData();

        for ($y = 1; $y <= $mapData->getHeight(); $y++) {
            for ($x = 1; $x <= $mapData->getWidth(); $x++) {
                $index = $x + ($y - 1) * $mapData->getWidth();

                $this->createSystemMap($x, $y, $fieldData[$index], $starSystem);
            }
        }
    }

    private function createSystemMap(int $x, int $y, int $fieldId, StarSystemInterface $starSystem): void
    {
        $systemMap = $this->starSystemMapRepository->prototype();
        $systemMap->setSx($x);
        $systemMap->setSy($y);
        $systemMap->setSystem($starSystem);
        $systemMap->setFieldType($this->getFieldType($fieldId));

        $this->starSystemMapRepository->save($systemMap);

        $starSystem->getFields()->add($systemMap);
    }

    private function getFieldType(int $fieldId): MapFieldTypeInterface
    {
        if (!array_key_exists($fieldId, $this->fieldTypeCache)) {
            $fieldType = $this->mapFieldTypeRepository->find($fieldId === 0 ? 1 : $fieldId);

            if ($fieldType === null) {
                throw new RuntimeException(sprintf('fieldId %d does not exist', $fieldId));
            }
            $this->fieldTypeCache[$fieldId] = $fieldType;
        }

        return $this->fieldTypeCache[$fieldId];
    }

    private function getStarSystem(MapInterface $map): StarSystemInterface
    {
        $starSystem = $map->getSystem();
        if ($starSystem === null) {
            $starSystem = $this->starSystemRepository->prototype();
            $map->setSystem($starSystem);
            $this->mapRepository->save($map);
        } else {
            $this->starSystemMapRepository->truncateByStarSystem($starSystem);
            $starSystem->getFields()->clear();
        }

        return $starSystem;
    }

    /**
     * @return array<int, int>
     */
    private function getMassCenterFields(MassCenterTypeInterface $massCenterType): array
    {
        $result = [];

        $firstId = $massCenterType->getFirstFieldType()->getId();

        for ($i = 0; $i < (int)pow($massCenterType->getSize(), 2); $i++) {
            $result[] = $firstId + $i;
        }

        return $result;
    }
}