Xoco70\KendoTournaments\TreeGen\DirectEliminationTreeGen

Complexity

Total Complexity

32

Size/Duplication

Total Lines	186
Duplicated Lines	27.42 %

Coupling/Cohesion

Components	4
Dependencies	3

Importance

Changes	3
Bugs	2	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	getByeGroup()	0	8	1
A	pushEmptyGroupsToTree()	0	6	1
A	chunkAndShuffle()	0	10	2
A	generateFights()	0	5	1
A	generateNextRoundsFights()	0	9	2
A	updateParentFight()	0	14	4
A	chooseAndUpdateParentFight()	0	10	3
B	getParentFighterToUpdate()	16	16	5
B	getValueToUpdate()	13	13	5
A	hasDeterminedParent()	9	9	4
A	pushGroups()	13	13	3
A	getNumRounds()	0	3	1

<?php

namespace Xoco70\KendoTournaments\TreeGen;

use Illuminate\Support\Collection;
use Illuminate\Support\Facades\App;
use Xoco70\KendoTournaments\Models\Championship;
use Xoco70\KendoTournaments\Models\DirectEliminationFight;
use Xoco70\KendoTournaments\Models\Fight;

class DirectEliminationTreeGen extends TreeGen
{

    /**
     * Calculate the Byes need to fill the Championship Tree.
     * @param $fighters
     * @return Collection
     */
    protected function getByeGroup($fighters)
    {
        $fighterCount = $fighters->count();
        $treeSize = $this->getTreeSize($fighterCount, 2);
        $byeCount = $treeSize - $fighterCount;

        return $this->createNullsGroup($byeCount);
    }


    /**
     * Create empty groups for direct Elimination Tree
     * @param $numFightersElim
     */
    public function pushEmptyGroupsToTree($numFightersElim)
    {
        // We calculate how much rounds we will have
        $numRounds = intval(log($numFightersElim, 2));
        $this->pushGroups($numRounds, $numFightersElim);
    }

    /**
     * Chunk Fighters into groups for fighting, and optionnaly shuffle
     * @param $fightersByEntity
     * @return Collection|null
     */
    protected function chunkAndShuffle($round = null, $fightersByEntity)

The parameter $round is not used and could be removed.

    {
        $fightersGroup = null;

$fightersGroup is not used, you could remove the assignment.

        $fightersGroup = $fightersByEntity->chunk(2);
        if (!App::runningUnitTests()) {
            $fightersGroup = $fightersGroup->shuffle();
        }
        return $fightersGroup;
    }


    /**
     * Generate First Round Fights
     */
    public function generateFights()
    {
        parent::destroyPreviousFights($this->championship);

It seems like you call parent on a different method (destroyPreviousFights() instead of generateFights()). Are you sure this is correct? If so, you might want to change this to $this->destroyPreviousFights().

The call to TreeGen::destroyPreviousFights() has too many arguments starting with $this->championship.

        DirectEliminationFight::saveFights($this->championship);
    }
    /**
     *
     */
    public function generateNextRoundsFights()
    {
        $fightersCount = $this->championship->competitors->count() + $this->championship->teams->count();
        $maxRounds = intval(ceil(log($fightersCount, 2)));
        for ($numRound = 1; $numRound < $maxRounds; $numRound++) {
            $fightsByRound = $this->championship->fightsByRound($numRound)->with('group.parent', 'group.children')->get();
            $this->updateParentFight($this->championship, $fightsByRound);
        }
    }


    /**
     * @param Championship $championship
     * @param $fightsByRound
     */
    private function updateParentFight(Championship $championship, $fightsByRound)
    {
        foreach ($fightsByRound as $fight) {
            $parentGroup = $fight->group->parent;
            if ($parentGroup == null) break;
            $parentFight = $parentGroup->fights->get(0); //TODO This Might change when extending to Preliminary

            // IN this $fight, is c1 or c2 has the info?
            if ($championship->isDirectEliminationType()) {
                // determine whether c1 or c2 must be updated
                $this->chooseAndUpdateParentFight($fight, $parentFight);
            }
        }
    }

    /**
     * @param $fight
     * @param $parentFight
     */
    private function chooseAndUpdateParentFight($fight, $parentFight)
    {
        $fighterToUpdate = $fight->getParentFighterToUpdate();
        $valueToUpdate = $fight->getValueToUpdate();
        // we need to know if the child has empty fighters, is this BYE or undetermined
        if ($fight->hasDeterminedParent() && $valueToUpdate != null) {
            $parentFight->$fighterToUpdate = $fight->$valueToUpdate;
            $parentFight->save();
        }
    }


    /**
     * Returns the parent field that need to be updated
     * @return null|string
     */
    public function getParentFighterToUpdate()

This method seems to be duplicated in your project.

    {
        $childrenGroup = $this->group->parent->children;

The property group does not exist. Did you maybe forget to declare it?

        foreach ($childrenGroup as $key => $children) {
            $childFight = $children->fights->get(0);
            if ($childFight->id == $this->id) {

The property id does not exist. Did you maybe forget to declare it?

                if ($key % 2 == 0) {
                    return "c1";
                }
                if ($key % 2 == 1) {
                    return "c2";
                }
            }
        }
        return null;
    }

    /**
     * In the original fight ( child ) return the field that contains data to copy to parent
     * @return null|string
     */
    public function getValueToUpdate()

This method seems to be duplicated in your project.

    {
        if ($this->c1 != null && $this->c2 != null) {

The property c1 does not exist. Did you maybe forget to declare it?

The property c2 does not exist. Did you maybe forget to declare it?

            return null;
        }
        if ($this->c1 != null) {
            return "c1";
        }
        if ($this->c2 != null) {
            return "c2";
        }
        return null;
    }

    /**
     * Check if we are able to fill the parent fight or not
     * If one of the children has c1 x c2, then we must wait to fill parent
     *
     * @return bool
     */
    public function hasDeterminedParent()

This method seems to be duplicated in your project.

    {
        if ($this->group->has2Fighters()) return true;
        foreach ($this->group->children as $child) {
            $fight = $child->fights->get(0);
            if ($fight->has2Fighters()) return false;
        }
        return true;
    }

    /**
     * Save Groups with their parent info
     * @param integer $numRounds
     * @param $numFightersElim
     */
    protected function pushGroups($numRounds, $numFightersElim)

This method seems to be duplicated in your project.

    {
        for ($roundNumber = 2; $roundNumber <= $numRounds; $roundNumber++) {
            // From last match to first match
            $maxMatches = ($numFightersElim / pow(2, $roundNumber));

            for ($matchNumber = 1; $matchNumber <= $maxMatches; $matchNumber++) {
                $fighters = $this->createByeGroup(2);
                $group = $this->saveGroup(1, $matchNumber, $roundNumber, null);
                $this->syncGroup($group, $fighters);

It seems like you code against a specific sub-type and not the parent class Xoco70\KendoTournaments\TreeGen\DirectEliminationTreeGen as the method syncGroup() does only exist in the following sub-classes of Xoco70\KendoTournaments\TreeGen\DirectEliminationTreeGen: Xoco70\KendoTournaments\TreeGen\DirectEliminationCompetitorTreeGen, Xoco70\KendoTournaments\TreeGen\DirectEliminationTeamTreeGen. Maybe you want to instanceof check for one of these explicitly?

            }
        }
    }

    /**
     * Return number of rounds for the tree based on fighter count
     * @param $numFighters
     * @return int
     */
    public function getNumRounds($numFighters){
        return intval(log($numFighters, 2));
    }
}