Stu\Module\Colony\Lib\ColonyLibFactory

Complexity

Total Complexity

13

Size/Duplication

Total Lines	177
Duplicated Lines	0 %

Test Coverage

Coverage

2.41%

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	createColonyShieldingManager()	0	8	1
A	createColonyProduction()	0	10	1
A	__construct()	0	21	1
A	createColonyProductionPreviewWrapper()	0	9	1
A	createColonyPopulationCalculator()	0	9	1
A	createBuildableRumpItem()	0	10	1
A	createColonySurface()	0	17	1
A	createColonyProductionSumReducer()	0	4	1
A	createColonyCommodityProduction()	0	9	1
A	createColonyListItem()	0	11	1
A	createModuleSelector()	0	21	1
A	createEpsProductionPreviewWrapper()	0	9	1
A	createBuildingFunctionWrapper()	0	5	1

<?php

declare(strict_types=1);

namespace Stu\Module\Colony\Lib;

use Doctrine\ORM\EntityManagerInterface;
use Override;

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

use Stu\Component\Colony\ColonyFunctionManagerInterface;
use Stu\Component\Colony\ColonyPopulationCalculator;
use Stu\Component\Colony\ColonyPopulationCalculatorInterface;
use Stu\Component\Colony\Commodity\ColonyCommodityProduction;
use Stu\Component\Colony\Commodity\ColonyCommodityProductionInterface;
use Stu\Component\Colony\Commodity\ColonyProductionSumReducer;
use Stu\Component\Colony\Commodity\ColonyProductionSumReducerInterface;
use Stu\Component\Colony\Shields\ColonyShieldingManager;
use Stu\Component\Colony\Shields\ColonyShieldingManagerInterface;
use Stu\Component\Ship\ShipModuleTypeEnum;
use Stu\Lib\Colony\PlanetFieldHostInterface;
use Stu\Lib\ColonyProduction\ColonyProduction;
use Stu\Lib\ModuleScreen\Addon\ModuleSelectorAddonFactoryInterface;
use Stu\Lib\ModuleScreen\ModuleSelector;
use Stu\Module\Commodity\Lib\CommodityCacheInterface;
use Stu\Module\Template\StatusBarFactoryInterface;
use Stu\Module\Twig\TwigPageInterface;
use Stu\Orm\Entity\BuildingInterface;
use Stu\Orm\Entity\ColonyInterface;
use Stu\Orm\Entity\CommodityInterface;
use Stu\Orm\Entity\ShipBuildplanInterface;
use Stu\Orm\Entity\ShipInterface;
use Stu\Orm\Entity\ShipRumpInterface;
use Stu\Orm\Entity\UserInterface;
use Stu\Orm\Repository\BuildingCommodityRepositoryInterface;
use Stu\Orm\Repository\BuildingRepositoryInterface;
use Stu\Orm\Repository\ColonyRepositoryInterface;
use Stu\Orm\Repository\FlightSignatureRepositoryInterface;
use Stu\Orm\Repository\ModuleRepositoryInterface;
use Stu\Orm\Repository\PlanetFieldRepositoryInterface;
use Stu\Orm\Repository\ResearchedRepositoryInterface;
use Stu\Orm\Repository\ShipBuildplanRepositoryInterface;
use Stu\Orm\Repository\ShipRepositoryInterface;
use Stu\Orm\Repository\ShipRumpModuleLevelRepositoryInterface;
use Stu\PlanetGenerator\PlanetGeneratorInterface;

final class ColonyLibFactory implements ColonyLibFactoryInterface
{
    public function __construct(
        private PlanetFieldRepositoryInterface $planetFieldRepository,
        private BuildingRepositoryInterface $buildingRepository,
        private ColonyRepositoryInterface $colonyRepository,
        private CommodityConsumptionInterface $commodityConsumption,
        private ShipRepositoryInterface $shipRepository,
        private ShipBuildplanRepositoryInterface $shipBuildplanRepository,
        private ResearchedRepositoryInterface $researchedRepository,
        private FlightSignatureRepositoryInterface $flightSignatureRepository,
        private PlanetGeneratorInterface $planetGenerator,
        private EntityManagerInterface $entityManager,
        private BuildingCommodityRepositoryInterface $buildingCommodityRepository,
        private ModuleRepositoryInterface $moduleRepository,
        private ShipRumpModuleLevelRepositoryInterface $shipRumpModuleLevelRepository,
        private TwigPageInterface $twigPage,
        private PlanetFieldTypeRetrieverInterface $planetFieldTypeRetriever,
        private ColonyFunctionManagerInterface $colonyFunctionManager,
        private ModuleSelectorAddonFactoryInterface $moduleSelectorAddonFactory,
        private CommodityCacheInterface $commodityCache,
        private StatusBarFactoryInterface $statusBarFactory
    ) {}

    #[Override]
    public function createBuildingFunctionWrapper(
        array $buildingfunctions
    ): BuildingFunctionWrapperInterface {
        return new BuildingFunctionWrapper($buildingfunctions);
    }

    #[Override]
    public function createColonySurface(
        PlanetFieldHostInterface $host,
        ?int $buildingId = null,
        bool $showUnderground = true
    ): ColonySurfaceInterface {
        return new ColonySurface(
            $this->planetFieldRepository,
            $this->buildingRepository,
            $this->colonyRepository,
            $this->researchedRepository,
            $this->planetGenerator,
            $this->entityManager,
            $this->planetFieldTypeRetriever,
            $host,
            $buildingId,
            $showUnderground
        );
    }

    #[Override]
    public function createColonyListItem(
        ColonyInterface $colony
    ): ColonyListItemInterface {
        return new ColonyListItem(
            $this,
            $this->planetFieldRepository,
            $this->commodityConsumption,
            $this->statusBarFactory,
            $colony,
            $this->flightSignatureRepository->getVisibleSignatureCount($colony)
        );
    }

    #[Override]
    public function createBuildableRumpItem(
        ShipRumpInterface $shipRump,
        UserInterface $currentUser
    ): BuildableRumpListItemInterface {
        return new BuildableRumpListItem(
            $this->shipRepository,
            $this->shipBuildplanRepository,
            $shipRump,
            $currentUser
        );
    }

    #[Override]
    public function createColonyProductionPreviewWrapper(
        BuildingInterface $building,
        PlanetFieldHostInterface $host
    ): ColonyProductionPreviewWrapper {
        return new ColonyProductionPreviewWrapper(
            $this,
            $building,
            $this->createColonyCommodityProduction($host)->getProduction()
        );
    }

    #[Override]
    public function createEpsProductionPreviewWrapper(
        PlanetFieldHostInterface $host,
        BuildingInterface $building
    ): ColonyEpsProductionPreviewWrapper {
        return new ColonyEpsProductionPreviewWrapper(
            $this->planetFieldRepository,
            $host,
            $building
        );
    }

    #[Override]
    public function createModuleSelector(
        ShipModuleTypeEnum $moduleType,
        ColonyInterface|ShipInterface $host,
        ShipRumpInterface $rump,
        UserInterface $user,
        ?ShipBuildplanInterface $buildplan = null
    ): ModuleSelector {

        $addon = $this->moduleSelectorAddonFactory->createModuleSelectorAddon($moduleType);

        return new ModuleSelector(
            $this->moduleRepository,
            $this->shipRumpModuleLevelRepository,
            $this->twigPage,
            $moduleType,
            $host,
            $rump,
            $user,
            $addon,
            $buildplan
        );
    }

    #[Override]
    public function createColonyProduction(
        CommodityInterface $commodity,
        int $production,
        ?int $pc = null
    ): ColonyProduction {
        return new ColonyProduction(
            $commodity,
            $production,
            $pc
        );
    }

    #[Override]
    public function createColonyShieldingManager(
        PlanetFieldHostInterface $host
    ): ColonyShieldingManagerInterface {
        return new ColonyShieldingManager(
            $this->planetFieldRepository,
            $this->colonyFunctionManager,
            $host
        );
    }

    #[Override]
    public function createColonyCommodityProduction(
        PlanetFieldHostInterface $host
    ): ColonyCommodityProductionInterface {
        return new ColonyCommodityProduction(
            $this->buildingCommodityRepository,
            $host,
            $this,
            $this->commodityCache
        );
    }

    #[Override]
    public function createColonyProductionSumReducer(): ColonyProductionSumReducerInterface
    {
        return new ColonyProductionSumReducer();
    }

    #[Override]
    public function createColonyPopulationCalculator(
        PlanetFieldHostInterface $host,
        ?array $production = null
    ): ColonyPopulationCalculatorInterface {

        return new ColonyPopulationCalculator(
            $host,
            $production ?? $this->createColonyCommodityProduction($host)->getProduction()
        );
    }
}