TournamentGenerator\Round

Complexity

Total Complexity

55

Size/Duplication

Total Lines	184
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	getGroups()	0	3	1
A	group()	0	4	1
A	addGroup()	0	6	3
A	__construct()	0	3	1
A	__toString()	0	2	1
A	getGames()	0	2	1
A	progress()	0	5	2
A	orderGroups()	0	3	1
A	getSkip()	0	2	1
A	getGroupsIds()	0	3	1
A	getTeams()	0	12	4
A	addTeam()	0	23	6
A	setSkip()	0	3	1
A	simulate()	0	6	3
B	splitTeams()	0	22	8
A	team()	0	4	1
A	disallowSkip()	0	3	1
A	resetGames()	0	5	2
A	isPlayed()	0	5	3
A	genGames()	0	7	2
B	sortTeams()	0	19	10
A	allowSkip()	0	3	1

<?php

namespace TournamentGenerator;

/**
 *
 */
class Round
{

	public $name = '';
	public $id = '';
	private $groups = [];
	private $games = [];
	private $teams = [];
	private $allowSkip = false;

	function __construct(string $name = '') {
		$this->id = uniqid();
		$this->name = $name;
	}
	public function __toString() {
		return $this->name;
	}

	public function addGroup(Group ...$groups){
		foreach ($groups as $group) {
			if ($group instanceof Group) $this->groups[] = $group;
			else throw new \Exception('Trying to add group which is not an instance of Group class.');
		}
		return $this;
	}
	public function group(array $settings = []) {
		$g = new Group($settings);
		$this->groups[] = $g->setSkip($this->allowSkip);
		return $g;
	}
	public function getGroups(){
		$this->orderGroups();
		return $this->groups;
	}
	public function getGroupsIds() {
		$this->orderGroups();
		return array_map(function($a) { return $a->id; }, $this->groups);
	}
	public function orderGroups() {
		usort($this->groups, function($a, $b){
			return $a->order - $b->order;
		});
	}

	public function allowSkip(){
		$this->allowSkip = true;
		return $this;
	}
	public function disallowSkip(){
		$this->allowSkip = false;
		return $this;
	}
	public function setSkip(bool $skip = false) {
		$this->allowSkip = $skip;
		return $this;
	}
	public function getSkip() {
		return $this->allowSkip;
	}

	public function genGames(){
		$g = 0;

The assignment to $g is dead and can be removed.

		foreach ($this->groups as $group) {
			$group->genGames();
			$this->games = array_merge($this->games, $group->orderGames());
		}
		return $this->games;
	}
	public function getGames() {
		return $this->games;
	}
	public function isPlayed(){
		foreach ($this->groups as $group) {
			if (!$group->isPlayed()) return false;
		}
		return true;
	}

	public function addTeam(...$teams) {
		foreach ($teams as $team) {
			if ($team instanceof Team)  {
				$this->teams[] = $team;
			}
			elseif (gettype($team) === 'array') {
				foreach ($team as $team2) {
					if ($team2 instanceof Team) $this->teams[] = $team2;
					$team2->groupResults[$this->id] = [
						'group' => $this,
						'points' => 0,
						'score'  => 0,
						'wins'   => 0,
						'draws'  => 0,
						'losses' => 0,
						'second' => 0,
						'third'  => 0
					];
				}
			}
			else throw new \Exception('Trying to add team which is not an instance of Team class');
		}
		return $this;
	}
	public function team(string $name = '') {
		$t = new Team($name);
		$this->teams[] = $t;
		return $t;
	}
	public function getTeams(bool $ordered = false, $ordering = POINTS) {

The constant TournamentGenerator\POINTS was not found. Maybe you did not declare it correctly or list all dependencies?

		if (count($this->teams) == 0) {
			$teams = [];
			foreach ($this->groups as $group) {
				$teams = array_merge($teams, $group->getTeams());
			}
			$this->teams = $teams;
		}
		if ($ordered) {
			$this->sortTeams($ordering);
		}
		return $this->teams;
	}
	public function sortTeams($ordering = POINTS) {

The constant TournamentGenerator\POINTS was not found. Maybe you did not declare it correctly or list all dependencies?

		$teams = [];

The assignment to $teams is dead and can be removed.

		$groupsIds = $this->getGroupsIds();
		switch ($ordering) {
			case POINTS:{
				uasort($this->teams, function($a, $b) use ($groupsIds) {
					if ($a->sumPoints($groupsIds) === $b->sumPoints($groupsIds) && $a->sumScore($groupsIds) === $b->sumScore($groupsIds)) return 0;
					if ($a->sumPoints($groupsIds) === $b->sumPoints($groupsIds)) return ($a->sumScore($groupsIds) > $b->sumScore($groupsIds) ? -1 : 1);
					return ($a->sumPoints($groupsIds) > $b->sumPoints($groupsIds) ? -1 : 1);
				});
				break;}
			case SCORE:{

The constant TournamentGenerator\SCORE was not found. Maybe you did not declare it correctly or list all dependencies?

				uasort($this->teams, function($a, $b) use ($groupsIds) {
					if ($a->sumScore($groupsIds) === $b->sumScore($groupsIds)) return 0;
					return ($a->sumScore($groupsIds) > $b->sumScore($groupsIds) ? -1 : 1);
				});
				break;}
		}
		return $this->teams;
	}

	public function splitTeams(...$groups) {

		if (count($groups) === 0) $groups = $this->getGroups();

		foreach ($groups as $key => $value) {
			if (gettype($value) === 'array') {
				unset($groups[$key]);
				$groups = array_merge($groups, $value);
			}
		}

		$teams = $this->getTeams();
		shuffle($teams);

		while (count($teams) > 0) {
			foreach ($groups as $group) {
				if ($group instanceof Group) {
					if (count($teams) > 0) $group->addTeam(array_shift($teams));
				}
			}
		}
		return $this;
	}

	public function progress(bool $blank = false){
		foreach ($this->groups as $group) {
			$group->progress($blank);
		}
		return $this;
	}

	public function simulate() {
		foreach ($this->groups as $group) {
			if ($group->isPlayed()) continue;
			$group->simulate([], false);
		}
		return $this;
	}
	public function resetGames() {
		foreach ($this->groups as $group) {
			$group->resetGames();
		}
		return $this;
	}
}