TournamentGenerator\Traits\WithTeams

Complexity

Total Complexity

24

Size/Duplication

Total Lines	179
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	3
Bugs	1	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	getTeamContainer()	0	2	1
A	getTeams()	0	17	4
A	sortTeams()	0	13	3
A	splitTeams()	0	23	6
A	team()	0	4	1
A	isSeeded()	0	7	3
A	filterTeams()	0	11	3
A	addTeam()	0	5	2
A	addTeamContainer()	0	3	1

<?php


namespace TournamentGenerator\Traits;

use Exception;
use TournamentGenerator\Constants;
use TournamentGenerator\Containers\TeamContainer;
use TournamentGenerator\Group;
use TournamentGenerator\Helpers\Filter;
use TournamentGenerator\Helpers\Functions;
use TournamentGenerator\Helpers\Sorter\TeamSorter;
use TournamentGenerator\Interfaces\WithGroups as WithGroupsInterface;
use TournamentGenerator\Interfaces\WithTeams as WithTeamsInterface;
use TournamentGenerator\Round;
use TournamentGenerator\Team;
use TournamentGenerator\TeamFilter;

/**
 * Trait WithTeams
 *
 * @package TournamentGenerator\Traits
 * @author  Tomáš Vojík <vojik@wboy.cz>
 * @since   0.4
 */
trait WithTeams
{

	/** @var TeamContainer Teams in a object */
	protected TeamContainer $teams;

	/**
	 * Create a new team and add it into the object
	 *
	 * @param string          $name Name of the new team
	 * @param string|int|null $id   Id of the new team - if omitted -> it is generated automatically as unique string
	 *
	 * @return Team Newly created team
	 * @throws Exception
	 */
	public function team(string $name = '', $id = null) : Team {
		$t = new Team($name, $id);
		$this->teams->insert($t);
		return $t;
	}

	/**
	 * Split teams into its Groups
	 *
	 * @param Round ...$wheres
	 *
	 * @return $this
	 * @throws Exception
	 * @noinspection CallableParameterUseCaseInTypeContextInspection
	 */
	public function splitTeams(Round ...$wheres) : WithTeamsInterface {
		if (count($wheres) === 0) {
			$wheres = $this->getRounds();

It seems like getRounds() must be provided by classes using this trait. How about adding it as abstract method to this trait?

		}

		$teams = $this->getTeams(true, Constants::SEED);
		if ($this::isSeeded($teams)) {
			Functions::sortAlternate($teams);
		}
		else {
			shuffle($teams);
		}

		$split = ceil(count($teams) / count($wheres));
		foreach ($wheres as $where) {
			if (count($teams) > 0) {
				$where->addTeam(...array_splice($teams, 0, $split));

$split of type double is incompatible with the type integer|null expected by parameter $length of array_splice().

			}
		}
		foreach ($wheres as $where) {
			$where->splitTeams();
		}
		return $this;
	}

	/**
	 * Get all teams in the object
	 *
	 * @param bool                        $ordered  If true - order the teams by their score/points
	 * @param string|null                 $ordering What to order the teams by - Constants::POINTS, Constants::SCORE
	 * @param TeamFilter[]|TeamFilter[][] $filters  Filters to filter the returned teams (ex. if you only want to get the first 3 teams)
	 *
	 * @return Team[]
	 * @throws Exception
	 */
	public function getTeams(bool $ordered = false, ?string $ordering = Constants::POINTS, array $filters = []) : array {
		if (is_null($ordering)) {
			$ordering = Constants::POINTS;
		}
		if ($ordered) {
			$returnTeams = $this->sortTeams($ordering);
		}
		else {
			$returnTeams = $this->teams->unique()->get();
		}

		// APPLY FILTERS
		if (count($filters) > 0) {
			$this->filterTeams($returnTeams, $filters);
		}

		return $returnTeams;
	}

	/**
	 * Sort the teams by their score/points
	 *
	 * @param string|null                 $ordering What to order the teams by - Constants::POINTS, Constants::SCORE
	 * @param TeamFilter[]|TeamFilter[][] $filters  Filters to filter the returned teams (ex. if you only want to get the first 3 teams)
	 *
	 * @return Team[]
	 * @throws Exception
	 */
	public function sortTeams(?string $ordering = Constants::POINTS, array $filters = []) : array {
		if (is_null($ordering)) {
			$ordering = Constants::POINTS;
		}
		$sorter = new TeamSorter($this->getContainer(), $ordering);
		$teams = $this->teams->addSorter($sorter)->unique()->get();

		// APPLY FILTERS
		if (count($filters) > 0) {
			$this->filterTeams($teams, $filters);
		}

		return $teams;
	}

	/**
	 * Filter teams using the specified filters
	 *
	 * @param array                       $teams   Teams to filter through
	 * @param TeamFilter[]|TeamFilter[][] $filters Filters to use
	 *
	 * @return array
	 * @throws Exception
	 */
	public function filterTeams(array &$teams, array $filters) : array {
		// APPLY FILTERS
		if ($this instanceof WithGroupsInterface) {
			$filter = new Filter($filters, $this->getGroups());
			$filter->filter($teams);
		}
		else if ($this instanceof Group) {
			$filter = new Filter($filters, [$this]);
			$filter->filter($teams);
		}
		return $teams;
	}

	/**
	 * @param Team[] $teams
	 *
	 * @return bool
	 */
	public static function isSeeded(array $teams) : bool {
		foreach ($teams as $team) {
			if ($team->getSeed() > 0) {
				return true;
			}
		}
		return false;
	}

	/**
	 * Add one or more teams into the object.
	 *
	 * @param Team ...$teams Team objects
	 *
	 * @return WithTeamsInterface
	 * @throws Exception
	 */
	public function addTeam(Team ...$teams) : WithTeamsInterface {
		foreach ($teams as $team) {
			$this->teams->insert($team);
		}
		return $this;
	}

	/**
	 * Get the container for games
	 *
	 * @return TeamContainer
	 */
	public function getTeamContainer() : TeamContainer {
		return $this->teams;
	}

	/**
	 * Add a child container for games
	 *
	 * @param TeamContainer $container
	 *
	 * @return WithTeamsInterface
	 * @throws Exception
	 */
	public function addTeamContainer(TeamContainer $container) : WithTeamsInterface {
		$this->teams->addChild($container);
		return $this;
	}
}