Stu\Module\Ship\Lib\ShipRetrofit

Complexity

Total Complexity

25

Size/Duplication

Total Lines	140
Duplicated Lines	0 %

Test Coverage

Coverage

2.67%

Importance

Changes	1
Bugs	1	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	addModuleSystems()	0	19	6
A	__construct()	0	8	1
C	updateBy()	0	73	13
A	createShipSystem()	0	13	2
A	addSpecialSystems()	0	7	3

<?php

declare(strict_types=1);

namespace Stu\Module\Ship\Lib;

use Override;

The type Override was not found. Maybe you did not declare it correctly or list all dependencies?

use Stu\Component\Spacecraft\SpacecraftModuleTypeEnum;
use Stu\Lib\Transfer\Storage\StorageManagerInterface;
use Stu\Component\Spacecraft\System\SpacecraftSystemTypeEnum;
use Stu\Component\Spacecraft\System\SpacecraftSystemModeEnum;

The type Stu\Component\Spacecraft\System\SpacecraftSystemModeEnum was not found. Maybe you did not declare it correctly or list all dependencies?

use Stu\Module\Message\Lib\PrivateMessageFolderTypeEnum;
use Stu\Module\Message\Lib\PrivateMessageSenderInterface;
use Stu\Module\PlayerSetting\Lib\UserEnum;

The type Stu\Module\PlayerSetting\Lib\UserEnum was not found. Maybe you did not declare it correctly or list all dependencies?

use Stu\Orm\Entity\ColonyInterface;
use Stu\Orm\Entity\ShipInterface;
use Stu\Orm\Entity\SpacecraftBuildplanInterface;
use Stu\Orm\Entity\ModuleInterface;
use Stu\Orm\Repository\SpacecraftSystemRepositoryInterface;
use Stu\Orm\Repository\BuildplanModuleRepositoryInterface;
use Stu\Orm\Repository\ModuleSpecialRepositoryInterface;
use Stu\Module\Spacecraft\Lib\SpacecraftWrapperFactoryInterface;
use Stu\Orm\Entity\BuildplanModuleInterface;


final class ShipRetrofit implements ShipRetrofitInterface
{
    public function __construct(
        private SpacecraftSystemRepositoryInterface $shipSystemRepository,
        private BuildplanModuleRepositoryInterface $buildplanModuleRepository,
        private ModuleSpecialRepositoryInterface $moduleSpecialRepository,
        private SpacecraftWrapperFactoryInterface $spacecraftWrapperFactory,
        private StorageManagerInterface $storageManager,
        private PrivateMessageSenderInterface $privateMessageSender
    ) {}

    #[Override]
    public function updateBy(ShipInterface $ship, SpacecraftBuildplanInterface $newBuildplan, ColonyInterface $colony): void
    {
        $oldBuildplan = $ship->getBuildplan();
        $wrapper = $this->spacecraftWrapperFactory->wrapShip($ship);
        $returnedmodules = [];

        if ($oldBuildplan === null) {
            return;
        }


        foreach (SpacecraftModuleTypeEnum::getModuleSelectorOrder() as $moduleType) {
            $oldModules = $this->buildplanModuleRepository->getByBuildplanAndModuleType($oldBuildplan->getId(), $moduleType->value);
            $newModules = $this->buildplanModuleRepository->getByBuildplanAndModuleType($newBuildplan->getId(), $moduleType->value);

            $addingModules = array_udiff($newModules, $oldModules, function ($a, $b): int {
                return $a->getModule()->getId() - $b->getModule()->getId();
            });

            $deletingModules = array_udiff($oldModules, $newModules, function ($a, $b): int {
                return $a->getModule()->getId() - $b->getModule()->getId();
            });

            if ($addingModules !== []) {
                $systems = [];
                $this->addModuleSystems($addingModules, $systems);
                foreach ($systems as $systemType => $module) {
                    $this->createShipSystem($systemType, $ship, $module);
                    $moduleRumpWrapper = $moduleType->getModuleRumpWrapperCallable()($ship->getRump(), $newBuildplan);
                    $moduleRumpWrapper->apply($wrapper);
                }
            }

            foreach ($deletingModules as $oldModule) {
                $system = $this->shipSystemRepository->getByShipAndModule($ship->getId(), $oldModule->getModule()->getId());
                if ($system !== null) {
                    if ($system->getStatus() >= 100 && mt_rand(1, 100) <= 25) {
                        $returnedmodules[] = $system->getModule();
                    }
                    $this->shipSystemRepository->delete($system);
                }
            }
        }

        if ($returnedmodules !== []) {
            $msg = "
            Die folgenden Module wurden durch den Umbau zurückgewonnen: ";
            foreach ($returnedmodules as $module) {
                if ($module != null) {
                    $this->storageManager->upperStorage($colony, $module->getCommodity(), 1);
                    $msg .= $module->getName() . ", ";
                }
            }
            $msg = rtrim($msg, ", ");
        } else {
            $msg = null;
        }

        $txt = _("Auf der Kolonie " . $colony->getName() . " wurde die " . $ship->getName() . " umgerüstet");

        if ($msg !== null) {
            $txt .= '. ' . $msg;
        }

        $this->privateMessageSender->send(
            UserEnum::USER_NOONE,
            $colony->getUserId(),
            $txt,
            PrivateMessageFolderTypeEnum::SPECIAL_COLONY
        );

        $ship->setBuildplan($newBuildplan);
    }

    /**
     * @param array<BuildplanModuleInterface> $modules
     * @param array<int, ModuleInterface|null> $systems
     */
    private function addModuleSystems(array $modules, array &$systems): void
    {
        foreach ($modules as $buildplanmodule) {
            $module = $buildplanmodule->getModule();

            $systemType = $module->getSystemType();
            if (
                $systemType === null
                && $module->getType()->hasCorrespondingSystemType()
            ) {
                $systemType = $module->getType()->getSystemType();
            }

            if ($systemType !== null) {
                $systems[$systemType->value] = $module;
            }

            if ($module->getType() === SpacecraftModuleTypeEnum::SPECIAL) {
                $this->addSpecialSystems($module, $systems);
            }
        }
    }

    /**
     * @param array<int, null|ModuleInterface> $systems
     */
    private function addSpecialSystems(ModuleInterface $module, array &$systems): void
    {
        $moduleSpecials = $this->moduleSpecialRepository->getByModule($module->getId());

        foreach ($moduleSpecials as $special) {
            $moduleSpecial = $special->getSpecialId();
            $systems[$moduleSpecial->getSystemType()->value] = $moduleSpecial->hasCorrespondingModule() ? $module : null;
        }
    }


    private function createShipSystem(int $systemType, ShipInterface $ship, ?ModuleInterface $module): void
    {
        $shipSystem = $this->shipSystemRepository->prototype();
        $shipSystem->setSpacecraft($ship);
        $ship->getSystems()->set($systemType, $shipSystem);
        $shipSystem->setSystemType(SpacecraftSystemTypeEnum::from($systemType));
        if ($module !== null) {
            $shipSystem->setModule($module);
        }
        $shipSystem->setStatus(100);
        $shipSystem->setMode(SpacecraftSystemModeEnum::MODE_OFF);

        $this->shipSystemRepository->save($shipSystem);
    }
}