TournamentGenerator\Game

Complexity

Total Complexity

45

Size/Duplication

Total Lines	340
Duplicated Lines	0 %

Test Coverage

Coverage

99.32%

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	getGroup()	0	2	1
A	setResults2()	0	19	3
A	getSecond()	0	2	1
A	getWin()	0	2	1
A	getTeam()	0	5	2
A	__construct()	0	3	1
B	setResults()	0	32	8
A	getLoss()	0	2	1
A	addTeam()	0	15	4
A	isPlayed()	0	2	1
A	getTeamsIds()	0	4	1
A	getDraw()	0	2	1
A	setResults3()	0	19	4
A	getThird()	0	2	1
A	getResults()	0	3	1
B	resetResults()	0	28	8
A	setResults4()	0	24	5
A	getTeams()	0	2	1

<?php

namespace TournamentGenerator;

use Exception;
use TypeError;

/**
 * Class Game
 *
 * @package TournamentGenerator
 * @author  Tomáš Vojík <vojik@wboy.cz>
 * @since   0.1
 */
class Game
{

	/** @var Team[] Teams playing this game */
	protected array $teams;
	/** @var array[] List of scores - [teamId => [score => value, type => win|loss|draw|second|third]] pairs */
	protected array $results = [];
	/** @var Group Group that the game belongs to */
	protected Group $group;
	/** @var int|string Id of the winning team */
	protected $winId;
	/** @var int|string Id of the losing team */
	protected $lossId;
	/** @var int|string Id of the second team */
	private $secondId;
	/** @var int|string Id of the third team */
	private $thirdId;
	/** @var int[]|string[] Ids of the teams that have drawn */
	private array $drawIds = [];

	/**
	 * Game constructor.
	 *
	 * @param Team[] $teams Teams that play in this game
	 * @param Group  $group Group that this game belongs to
	 */
	public function __construct(array $teams, Group $group) {
		$this->group = $group;
		$this->addTeam(...$teams);
	}

	/**
	 * Add teams to this game
	 *
	 * @param Team[] $teams
	 *
	 * @return $this
	 */
	public function addTeam(Team ...$teams) : Game {
		foreach ($teams as $team) {
			$this->teams[] = $team;
			$team->addGame($this);

			// Log games with this added teams to all teams added before
			foreach ($this->teams as $team2) {
				if ($team === $team2) {
					continue;
				}
				$team->addGameWith($team2, $this->group);
				$team2->addGameWith($team, $this->group);
			}
		}
		return $this;
	}

	/**
	 * Get the parent group object
	 *
	 * @return Group
	 */
	public function getGroup() : Group {
		return $this->group;
	}

	/**
	 * Get all teams from the game
	 *
	 * @return Team[]
	 */
	public function getTeams() : array {
		return $this->teams;
	}

	/**
	 * Get all team ids from this game
	 *
	 * @return string[]|int[]
	 */
	public function getTeamsIds() : array {
		return array_map(static function($a) {
			return $a->getId();
		}, $this->teams);
	}

	/**
	 * Get results
	 *
	 * @return array[]
	 */
	public function getResults() : array {
		ksort($this->results);
		return $this->results;
	}

	/**
	 * Set the game's results
	 *
	 * Results is an array of [teamId => teamScore] key-value pairs.
	 *
	 * @param int[] $results array of [teamId => teamScore] key-value pairs
	 *
	 * @return $this
	 * @throws Exception
	 */
	public function setResults(array $results = []) : Game {
		if (count($this->results) === 0) {
			$this->resetResults();
		}
		arsort($results);
		$inGame = $this->group->getInGame();
		$i = 1;
		foreach ($results as $id => $score) {
			if (!is_numeric($score)) {
				throw new TypeError('Score passed to TournamentGenerator\Game::setResults() must be of the type numeric, '.gettype($score).' given');
			}
			$team = $this->getTeam($id);
			if (!isset($team)) {
				throw new Exception('Couldn\'t find team with id of "'.$id.'"');
			}
			$this->results[$team->getId()] = ['score' => $score];
			$team->addScore($score);
			switch ($inGame) {
				case 2:
					$this->setResults2($i, $score, $results, $team);
					break;
				case 3:
					$this->setResults3($i, $team);
					break;
				case 4:
					$this->setResults4($i, $team);
					break;
			}
			$team->groupResults[$this->group->getId()]['score'] += $score;
			$i++;
		}
		return $this;
	}

	/**
	 * Reset the game's results
	 *
	 * @post Scores are removed
	 * @post Team points are subtracted
	 *
	 * @return $this
	 * @throws Exception
	 */
	public function resetResults() : Game {
		foreach ($this->results as $teamId => $score) {
			$team = $this->getTeam($teamId);
			if (!isset($team)) {
				throw new Exception('Cannot find team with id: '.$teamId.' in game');
			}
			$team->groupResults[$this->group->getId()]['score'] -= $score['score'];
			$team->removeScore($score['score']);
			switch ($score['type']) {
				case 'win':
					$team->removeWin($this->group->getId());
					break;
				case 'draw':
					$team->removeDraw($this->group->getId());
					break;
				case 'loss':
					$team->removeLoss($this->group->getId());
					break;
				case 'second':
					$team->removeSecond($this->group->getId());
					break;
				case 'third':
					$team->removeThird($this->group->getId());
					break;
			}
		}
		$this->results = [];
		return $this;
	}

	/**
	 * Get team by ID
	 *
	 * @param string|int $id Team ID
	 *
	 * @return Team|null
	 */
	public function getTeam($id) : ?Team {
		$key = array_search($id, array_map(static function($a) {
			return $a->getId();
		}, $this->teams), true);
		return ($key !== false ? $this->teams[$key] : null);
	}

	/**
	 * Set results for 2 team game
	 *
	 * @param int   $teamPosition Team's position (first = 1, second = 2)
	 * @param int   $score        Team's score
	 * @param int[] $results      Results array (for draw checking)
	 * @param Team  $team         Team object
	 *
	 * @return $this
	 * @throws Exception
	 */
	protected function setResults2(int $teamPosition, int $score, array $results, Team $team) : Game {
		if (count(array_filter($results, static function($a) use ($score) {
				return $a === $score;
			})) > 1) {
			$this->drawIds[] = $team->getId();
			$team->addDraw($this->group->getId());
			$this->results[$team->getId()] += ['points' => $this->group->getDrawPoints(), 'type' => 'draw'];
		}
		elseif ($teamPosition === 1) {
			$this->winId = $team->getId();
			$team->addWin($this->group->getId());
			$this->results[$team->getId()] += ['points' => $this->group->getWinPoints(), 'type' => 'win'];
		}
		else {
			$this->lossId = $team->getId();
			$team->addLoss($this->group->getId());
			$this->results[$team->getId()] += ['points' => $this->group->getLostPoints(), 'type' => 'loss'];
		}
		return $this;
	}

	/**
	 * Set results for 3 team game
	 *
	 * @param int  $teamPosition Team's position (first = 1, second = 2, third = 3)
	 * @param Team $team         Team object
	 *
	 * @return $this
	 * @throws Exception
	 */
	protected function setResults3(int $teamPosition, Team $team) : Game {
		switch ($teamPosition) {
			case 1:
				$this->winId = $team->getId();
				$team->addWin($this->group->getId());
				$this->results[$team->getId()] += ['points' => $this->group->getWinPoints(), 'type' => 'win'];
				break;
			case 2:
				$this->secondId = $team->getId();
				$team->addSecond($this->group->getId());
				$this->results[$team->getId()] += ['points' => $this->group->getSecondPoints(), 'type' => 'second'];
				break;
			case 3:
				$this->lossId = $team->getId();
				$team->addLoss($this->group->getId());
				$this->results[$team->getId()] += ['points' => $this->group->getLostPoints(), 'type' => 'loss'];
				break;
		}
		return $this;
	}

	/**
	 * Set results for 4 team game
	 *
	 * @param int  $teamPosition Team's position (first = 1, second = 2, third = 3, fourth = 4)
	 * @param Team $team         Team object
	 *
	 * @return Game
	 * @throws Exception
	 */
	protected function setResults4(int $teamPosition, Team $team) : Game {
		switch ($teamPosition) {
			case 1:
				$this->winId = $team->getId();
				$team->addWin($this->group->getId());
				$this->results[$team->getId()] += ['points' => $this->group->getWinPoints(), 'type' => 'win'];
				break;
			case 2:
				$this->secondId = $team->getId();
				$team->addSecond($this->group->getId());
				$this->results[$team->getId()] += ['points' => $this->group->getSecondPoints(), 'type' => 'second'];
				break;
			case 3:
				$this->thirdId = $team->getId();
				$team->addThird($this->group->getId());
				$this->results[$team->getId()] += ['points' => $this->group->getThirdPoints(), 'type' => 'third'];
				break;
			case 4:
				$this->lossId = $team->getId();
				$team->addLoss($this->group->getId());
				$this->results[$team->getId()] += ['points' => $this->group->getLostPoints(), 'type' => 'loss'];
				break;
		}
		return $this;
	}

	/**
	 * Get the winning team's id
	 *
	 * @return int|string
	 */
	public function getWin() {
		return $this->winId;
	}

	/**
	 * Get the losing team's id
	 *
	 * @return int|string
	 */
	public function getLoss() {
		return $this->lossId;
	}

	/**
	 * Get the second team's id
	 *
	 * @return int|string
	 */
	public function getSecond() {
		return $this->secondId;
	}

	/**
	 * Get the third team's id
	 *
	 * @return int|string
	 */
	public function getThird() {
		return $this->thirdId;
	}

	/**
	 * Get the draws teams' id
	 *
	 * @return int[]|string[]
	 */
	public function getDraw() : array {
		return $this->drawIds;
	}

	/**
	 * Check if the game has been played
	 *
	 * @return bool
	 */
	public function isPlayed() : bool {
		return count($this->results) > 0;
	}
}