App\Jobs\Tournament\DrawLeague

Complexity

Total Complexity

20

Size/Duplication

Total Lines	184
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	setTournament()	0	20	2
A	handle()	0	17	3
A	draw()	0	6	1
B	drawBergerTable()	0	24	5
A	addReversMarches()	0	14	3
A	isOddTeamsCnt()	0	7	2
A	setPairCnt()	0	4	1
A	saveRounds()	0	19	3

<?php

namespace App\Jobs\Tournament;

use App\Match;
use App\Tournament;
use Illuminate\Database\Eloquent\Collection;

/**
 * Class DrawLeague
 * @package App\Jobs\Tournament
 */
class DrawLeague extends Job
{
    /**
     * @var array
     */
    protected $teams = [];

    /**
     * @var Collection
     */
    protected $rounds;

    /**
     * @var Collection
     */
    protected $matches;

    /**
     * @var boolean
     */
    protected $isOdd = false;

    /**
     * @var int
     */
    protected $teamsCount;

    /**
     * @var int
     */
    protected $pairCnt;

    /**
     * @name setTournament
     * @param Tournament $tournament
     */
    protected function setTournament(Tournament $tournament)
    {
        $this->tournament = $tournament;

        foreach ($this->tournament->tournamentTeams()->getResults() as $team) {
            $team->team->homeMatchesAmount = 0;
            $team->team->wasPulledOut = false;
            $team->team->pulledOut = false;
            $this->teams[] = [
                'id' => $team->id,
                'name' => $team->team->name
            ];
        }

        shuffle($this->teams);

        $this->teamsCount = count($this->teams);
        $this->isOddTeamsCnt();
        $this->setPairCnt();
    }

    /**
     * Handle the job
     *
     * @return void
     * @throws \UnexpectedValueException
     */
    public function handle()
    {
        if (Tournament::MIN_TEAMS_AMOUNT > count($this->teams)) {
            throw new \UnexpectedValueException('Tournament should have at least 2 teams.');
        }

        /**
         * @var $matches Collection
         */
        $matches = $this->tournament->matches()->getResults();

        if (0 < $matches->count()) {
            throw new \UnexpectedValueException('Tournament draw has been already done.');
        }

        $this->draw();
    }

    /**
     * @name draw
     */
    protected function draw()
    {
        $table = $this->drawBergerTable();

        $this->saveRounds($table);
    }

    /**
     * Create scheduling for one season by Berger algorithm https://en.wikipedia.org/wiki/Round-robin_tournament
     * @name drawBergerTable
     * @return array
     */
    protected function drawBergerTable()
    {
        $a = [];
        $table = [];

        for ($i = 1; $i < $this->teamsCount; $i++) {
            $a[] = $i;
        }

        for ($i = 0; $i < $this->teamsCount - 1; $i++) {
            $table[$i] = [];
            if (!$this->isOdd) {
                $table[$i][] = [$a[0], $this->teamsCount];
            }
            for ($j = 1; $j < $this->pairCnt; $j++) {
                $table[$i][] = [$a[$j], $a[$this->teamsCount - 1 - $j]];
            }
            $a[] = array_shift($a);
        }

        $table = $this->addReversMarches($table);

        return $table;
    }

    /**
     * @name addReversMarches
     * @param $table
     * @return array
     */
    protected function addReversMarches($table)
    {
        for ($i = count($table) - 1; $i >= 0; $i--) {
            $day = $table[$i];

            $nDay = [];
            foreach ($day as $match) {
                $nDay[] = [$match[1], $match[0]];
            }
            $table[] = $nDay;
        }

        return $table;
    }

    /**
     * Check if teams is odd count
     * @name isOddTeamsCnt
     */
    protected function isOddTeamsCnt()
    {
        if ($this->teamsCount % 2 != 0) {
            $this->isOdd = true;
            $this->teamsCount++;
        }
    }

    /**
     * @name setPairCnt
     */
    protected function setPairCnt()
    {
        $this->pairCnt = (int)$this->teamsCount / 2;
    }

    /**
     * @name saveRounds
     */
    protected function saveRounds($table)
    {
        foreach ($table as $key => $round) {
            foreach ($round as $match) {
                $this->tournament->matches()->create([
                    'homeTournamentTeamId' => $this->teams[$match[0] - 1]['id'],
                    'awayTournamentTeamId' => $this->teams[$match[1] - 1]['id'],
                    'homeScore' => 0,
                    'awayScore' => 0,
                    'homePenaltyScore' => 0,
                    'awayPenaltyScore' => 0,
                    'round' => $key + 1,
                    'gameType' => Match::GAME_TYPE_GROUP_STAGE,
                    'resultType' => Match::RESULT_TYPE_UNKNOWN,
                    'status' => Match::STATUS_NOT_STARTED
                ]);
            }
        }
    }
}