TournamentGenerator\Tournament

Complexity

Total Complexity

64

Size/Duplication

Total Lines	224
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	0

29 Methods

Rating	Name	Duplication	Size	Complexity
A	addRound()	0	6	3
A	setCategoryWait()	0	3	1
A	getPlay()	0	2	1
A	setRoundWait()	0	3	1
A	getRounds()	0	9	3
A	getCategories()	0	2	1
A	setGameWait()	0	3	1
A	getTournamentTime()	0	3	1
A	setSkip()	0	3	1
A	addCategory()	0	6	3
A	disallowSkip()	0	3	1
A	category()	0	4	1
A	getGameWait()	0	2	1
A	getCategoryWait()	0	2	1
A	setPlay()	0	3	1
A	round()	0	4	1
A	allowSkip()	0	3	1
A	getSkip()	0	2	1
A	getRoundWait()	0	2	1
A	team()	0	4	1
A	__construct()	0	2	1
A	addTeam()	0	13	6
A	__toString()	0	2	1
A	getTeams()	0	15	5
A	getGames()	0	6	2
A	sortTeams()	0	8	2
A	genGamesSimulateReal()	0	16	6
B	splitTeams()	0	24	8
B	genGamesSimulate()	0	18	7

<?php

namespace TournamentGenerator;

/**
 *
 */
class Tournament
{

	public $name = '';
	private $categories = [];
	private $rounds = [];
	private $teams = [];

	private $expectedPlay = 0;
	private $expectedGameWait = 0;
	private $expectedRoundWait = 0;
	private $expectedCategoryWait = 0;

	private $allowSkip = false;

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

	public function setPlay(int $play) {
		$this->expectedPlay = $play;
		return $this;
	}
	public function getPlay() {
		return $this->expectedPlay;
	}
	public function setGameWait(int $wait) {
		$this->expectedGameWait = $wait;
		return $this;
	}
	public function getGameWait() {
		return $this->expectedGameWait;
	}
	public function setRoundWait(int $wait) {
		$this->expectedRoundWait = $wait;
		return $this;
	}
	public function getRoundWait() {
		return $this->expectedRoundWait;
	}
	public function setCategoryWait(int $wait) {
		$this->expectedCategoryWait = $wait;
		return $this;
	}
	public function getCategoryWait() {
		return $this->expectedCategoryWait;
	}
	public function getTournamentTime(){
		$games = count($this->getGames());
		return $games*$this->expectedPlay+$games*$this->expectedGameWait+count($this->getRounds())*$this->expectedRoundWait+count($this->getCategories())*$this->expectedCategoryWait;
	}

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

	public function addCategory(Category ...$categories){
		foreach ($categories as $category) {
			if ($category instanceof Category) $this->categories[] = $category;
			else throw new \Exception('Trying to add category which is not an instance of the Category class.');
		}
		return $this;
	}
	public function category(string $name = '') {
		$c = new Category($name);
		$this->categories[] = $c->setSkip($this->allowSkip);
		return $c;
	}
	public function getCategories() {
		return $this->categories;
	}

	public function addRound(Round ...$rounds) {
		foreach ($rounds as $round) {
			if ($round instanceof Round) $this->rounds[] = $round;
			else throw new \Exception('Trying to add round which is not an instance of the Round class.');
		}
		return $this;
	}
	public function round(string $name = '') {
		$r = new Round($name);
		$this->rounds[] = $r->setSkip($this->allowSkip);
		return $r;
	}
	public function getRounds() {
		if (count($this->categories) > 0) {
			$rounds = [];
			foreach ($this->categories as $category) {
				$rounds = array_merge($rounds, $category->getRounds());
			}
			return $rounds;
		}
		return $this->rounds;
	}

	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;
				}
			}
			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) {
		if (count($this->teams) === 0) {
			$teams = [];
			foreach ($this->categories as $category) {
				$teams = array_merge($teams, $category->getTeams());
			}
			foreach ($this->rounds as $round) {
				$teams = array_merge($teams, $round->getTeams());
			}
			$this->teams = $teams;
		}
		if ($ordered) {
			$this->sortTeams($ordering);
		}
		return $this->teams;
	}
	public function sortTeams($ordering = \POINTS) {
		$teams = [];
		for ($i = count($this->rounds)-1; $i >= 0; $i--) {
			$rTeams = array_filter($this->rounds[$i]->getTeams(true, $ordering), function($a) use ($teams) { return !in_array($a, $teams); });
			$teams = array_merge($teams, $rTeams);
		}
		$this->teams = $teams;
		return $this->teams;
	}

	public function getGames() {
		$games = [];
		foreach ($this->getRounds() as $round) {
			$games = array_merge($games, $round->getGames());
		}
		return $games;
	}

	public function splitTeams(Round ...$wheres) {

		if (count($wheres) === 0) $wheres = $this->getRounds();

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

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

		while (count($teams) > 0) {
			foreach ($wheres as $where) {
				if (count($teams) > 0) $where->addTeam(array_shift($teams));
			}
		}
		foreach ($wheres as $where) {
			$where->splitTeams();
		}
		return $this;
	}

	public function genGamesSimulate(bool $returnTime = false) {
		$games = [];
		if (count($this->categories) === 0 && count($this->rounds) === 0) throw new \Exception('There are no rounds or categories to simulate games from.');

		foreach ($this->categories as $category) {
			$games = array_merge($games, $category->genGamesSimulate());
		}

		foreach ($this->rounds as $round) {
			$games = array_merge($games, $round->genGames());
			$round->simulate()->progress(true);
		}
		foreach ($this->rounds as $round) {
			$round->resetGames();
		}

		if ($returnTime) return $this->getTournamentTime();
		return $games;
	}
	public function genGamesSimulateReal(bool $returnTime = false) {
		$games = [];
		if (count($this->categories) === 0 && count($this->rounds) === 0) throw new \Exception('There are no rounds or categories to simulate games from.');

		foreach ($this->categories as $category) {
			$games = array_merge($games, $category->genGamesSimulate());
		}

		foreach ($this->rounds as $round) {
			$games = array_merge($games, $round->genGames());
			$round->simulate();
			$round->progress();
		}

		if ($returnTime) return $this->getTournamentTime();
		return $games;
	}

}