Xoco70\LaravelTournaments\TreeGen\TreeGen

Complexity

Total Complexity

55

Size/Duplication

Total Lines	518
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	8

Importance

Changes

0

36 Methods

Rating	Name	Duplication	Size	Complexity
	addFighterToGroup()	0	1	?
	chunkAndShuffle()	0	1	?
	createByeFighter()	0	1	?
	generateAllTrees()	0	1	?
	generateFights()	0	1	?
	generateGroupsForRound()	0	1	?
	getByeGroup()	0	1	?
	getFighter()	0	1	?
	getFighters()	0	1	?
	getNumRounds()	0	1	?
	syncGroup()	0	1	?
A	__construct()	0	7	1
A	run()	0	6	1
B	update()	0	37	6
A	getMaxFightersByEntity()	0	9	1
A	getFightersByEntity()	0	11	2
B	getTreeSize()	0	22	4
A	repart()	0	14	4
A	insertByes()	0	13	3
A	saveGroup()	0	18	3
A	createByeGroup()	0	10	2
A	adjustFightersGroupWithByes()	0	15	1
A	getPreviousRound()	0	6	1
A	getParentGroup()	0	7	1
A	getFightersByArea()	0	12	1
A	addParentToChildren()	0	19	3
A	getFullFighterList()	0	16	3
A	shouldInsertBye()	0	4	3
A	destroyPreviousFights()	0	6	1
A	generateNextRoundsFights()	0	9	2
A	updateParentFight()	0	13	3
A	chooseAndUpdateParentFight()	0	17	3
A	getNumArea()	0	12	1
A	generateAllFights()	0	8	1
A	getWinnerId()	0	7	2
A	updateFight()	0	15	2

<?php

namespace Xoco70\LaravelTournaments\TreeGen;

use Illuminate\Database\QueryException;
use Illuminate\Support\Collection;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Xoco70\LaravelTournaments\Contracts\TreeGenerable;
use Xoco70\LaravelTournaments\Exceptions\DuplicatedException;
use Xoco70\LaravelTournaments\Exceptions\DuplicatedFighterException;
use Xoco70\LaravelTournaments\Exceptions\TreeGenerationException;
use Xoco70\LaravelTournaments\Models\Championship;
use Xoco70\LaravelTournaments\Models\Fight;
use Xoco70\LaravelTournaments\Models\FightersGroup;

abstract class TreeGen implements TreeGenerable
{
    protected $groupBy;
    protected $tree;
    public $championship;
    public $settings;
    protected $numFighters;

    abstract protected function addFighterToGroup(FightersGroup $group, $fighter);

    abstract protected function chunkAndShuffle(Collection $fightersByEntity);

    abstract protected function createByeFighter();

    abstract protected function generateAllTrees();

    abstract protected function generateFights();

    abstract protected function generateGroupsForRound(Collection $fightersByArea, $round);

    abstract protected function getByeGroup($fighters);

    abstract protected function getFighter($fighterId);

    abstract protected function getFighters();

    abstract protected function getNumRounds($fightersCount);

    abstract protected function syncGroup(FightersGroup $group, $fighters);

    /**
     * @param Championship $championship
     * @param $groupBy
     */
    public function __construct(Championship $championship, $groupBy)
    {
        $this->championship = $championship;
        $this->groupBy = $groupBy;
        $this->settings = $championship->getSettings();
        $this->tree = new Collection();
    }

    /**
     * Generate tree groups for a championship.
     *
     * @throws TreeGenerationException
     */
    public function run()
    {
        $this->championship->fightersGroups()->delete();
        $this->generateAllTrees();
        $this->generateAllFights();
    }

    /**
     * Generate tree groups for a championship.
     *
     * @throws TreeGenerationException
     */
    public function update(Request $request)
    {
        $fighters = $request->fighters;
        $winners = $request->winners;

        // get fightersGroup with fights
        $query = FightersGroup::with('fights', 'competitors', 'teams')

The method where does only exist in Illuminate\Database\Eloquent\Builder, but not in Illuminate\Database\Eloquent\Model.

            ->where('championship_id', $this->championship->id);

//        if ($this->championship->hasPreliminary()) {

59% of this comment could be valid code. Did you maybe forget this after debugging?

//            $query = $query->where('round', '=', 1);
//        }
        $groups = $query->get();
        $numFighter = 0;
        // Open Transaction, and change Fights and groups_fighters
        DB::beginTransaction();
        try {
            foreach ($groups as $group) {
                foreach ($group->fights as $fight) {
                    // Update Fight
                    $olds = [$fight->c1, $fight->c2];
                    $numFighter = $this->updateFight($fighters, $numFighter, $fight, $winners);
                    $this->updateGroupFighters($group, $fight, $olds);

The method updateGroupFighters() does not exist on Xoco70\LaravelTournaments\TreeGen\TreeGen. Did you maybe mean update()?

                }
            }
        } catch (QueryException $e) {
            $errorCode = $e->errorInfo[1];
            if ($errorCode == 1062) {
                DB::rollBack();
                back()->withErrors(trans('laravel-tournaments::core.duplicated_fighter_in_group'));
            }
        } catch (DuplicatedFighterException $e) {
            DB::rollBack();
            back()->withErrors(trans('laravel-tournaments::core.duplicated_fighter_in_group'));
        }
        DB::commit();
    }

    /**
     * Get the biggest entity group.
     *
     * @param $userGroups
     *
     * @return int
     */
    private function getMaxFightersByEntity($userGroups): int
    {
        return $userGroups
            ->sortByDesc(function ($group) {
                return $group->count();
            })
            ->first()
            ->count();
    }

    /**
     * Get Competitor's list ordered by entities
     * Countries for Internation Tournament, State for a National Tournament, etc.
     *
     * @param $fighters
     *
     * @return Collection
     */
    private function getFightersByEntity($fighters): Collection
    {
        // Right now, we are treating users and teams as equals.
        // It doesn't matter right now, because we only need name attribute which is common to both models

        // $this->groupBy contains federation_id, association_id, club_id, etc.
        if (($this->groupBy) != null) {
            return $fighters->groupBy($this->groupBy); // Collection of Collection
        }
        return $fighters->chunk(1); // Collection of Collection
    }

    /**
     * Get the size the first round will have.
     *
     * @param $fighterCount
     * @param $groupSize
     *
     * @return int
     */
    protected function getTreeSize($fighterCount, $groupSize)
    {
        $squareMultiplied = collect([1, 2, 4, 8, 16, 32, 64])
            ->map(function ($item) use ($groupSize) {
                return $item * $groupSize;
            }); // [4, 8, 16, 32, 64,...]

73% of this comment could be valid code. Did you maybe forget this after debugging?

        foreach ($squareMultiplied as $limit) {
            if ($fighterCount <= $limit) {
                $treeSize = $limit;
                $numAreas = $this->championship->getSettings()->fightingAreas;
                $fighterCountPerArea = $treeSize / $numAreas;
                if ($fighterCountPerArea < $groupSize) {
                    $treeSize = $treeSize * $numAreas;
                }

                return $treeSize;
            }
        }

        return 64 * $groupSize;
    }

    /**
     * Repart BYE in the tree,.
     *
     * @param $fighterGroups
     * @param int $max
     *
     * @return Collection
     */
    private function repart($fighterGroups, $max)
    {
        $fighters = new Collection();
        for ($i = 0; $i < $max; $i++) {
            foreach ($fighterGroups as $fighterGroup) {
                $fighter = $fighterGroup->values()->get($i);
                if ($fighter != null) {
                    $fighters->push($fighter);
                }
            }
        }

        return $fighters;
    }

    /**
     * Insert byes in an homogen way.
     *
     * @param Collection $fighters
     * @param Collection $byeGroup
     *
     * @return Collection
     */
    private function insertByes(Collection $fighters, Collection $byeGroup)
    {
        $bye = count($byeGroup) > 0 ? $byeGroup[0] : [];
        $sizeFighters = count($fighters);
        $sizeGroupBy = count($byeGroup);

        $frequency = $sizeGroupBy != 0
            ? (int)floor($sizeFighters / $sizeGroupBy)
            : -1;

        // Create Copy of $competitors
        return $this->getFullFighterList($fighters, $frequency, $sizeGroupBy, $bye);
    }


    /**
     * @param $order
     * @param $round
     * @param $parent
     *
     * @return FightersGroup
     */
    protected function saveGroup($order, $round, $parent): FightersGroup
    {
        $group = new FightersGroup();
        $this->championship->isSingleEliminationType()
            ? $group->area = $this->getNumArea($round, $order)
            : $group->area = 1; // Area limited to 1 in playoff


        $group->order = $order;
        $group->round = $round;
        $group->championship_id = $this->championship->id;
        if ($parent != null) {
            $group->parent_id = $parent->id;
        }
        $group->save();

        return $group;
    }

    /**
     * @param int $groupSize
     *
     * @return Collection
     */
    public function createByeGroup($groupSize): Collection
    {
        $byeFighter = $this->createByeFighter();
        $group = new Collection();
        for ($i = 0; $i < $groupSize; $i++) {
            $group->push($byeFighter);
        }

        return $group;
    }

    /**
     * @param $fighters
     * @param Collection $fighterGroups
     *
     * @return Collection
     */
    public function adjustFightersGroupWithByes($fighters, $fighterGroups): Collection
    {
        $tmpFighterGroups = clone $fighterGroups;
        $byeGroup = $this->getByeGroup($fighters);

        // Get biggest competitor's group
        $max = $this->getMaxFightersByEntity($tmpFighterGroups);

        // We reacommodate them so that we can mix them up and they don't fight with another competitor of his entity.

        $fighters = $this->repart($fighterGroups, $max);
        $fighters = $this->insertByes($fighters, $byeGroup);

        return $fighters;
    }

    /**
     * Get All Groups on previous round.
     *
     * @param $currentRound
     *
     * @return Collection
     */
    private function getPreviousRound($currentRound)
    {
        $previousRound = $this->championship->groupsByRound($currentRound + 1)->get();

        return $previousRound;
    }

    /**
     * Get the next group on the right ( parent ), final round being the ancestor.
     *
     * @param $matchNumber
     * @param Collection $previousRound
     *
     * @return mixed
     */
    private function getParentGroup($matchNumber, $previousRound)
    {
        $parentIndex = intval(($matchNumber + 1) / 2);
        $parent = $previousRound->get($parentIndex - 1);

        return $parent;
    }

    /**
     * Group Fighters by area.
     *
     * @throws TreeGenerationException
     *
     * @return Collection
     */
    protected function getFightersByArea()
    {
        // If previous trees already exists, delete all
        $areas = $this->settings->fightingAreas;
        $fighters = $this->getFighters();

        // Get Competitor's / Team list ordered by entities ( Federation, Assoc, Club, etc...)
        $fighterByEntity = $this->getFightersByEntity($fighters); // Chunk(1)
        $fightersWithBye = $this->adjustFightersGroupWithByes($fighters, $fighterByEntity);
        // Chunk user by areas
        return $fightersWithBye->chunk(count($fightersWithBye) / $areas);
    }

    /**
     * Attach a parent to every child for nestedSet Navigation.
     *
     * @param $numFightersElim
     */
    protected function addParentToChildren($numFightersElim)
    {
        $numRounds = $this->getNumRounds($numFightersElim);
        $groupsDesc = $this->championship
            ->fightersGroups()
            ->where('round', '<', $numRounds)
            ->orderByDesc('id')->get();

        $groupsDescByRound = $groupsDesc->groupBy('round');

        foreach ($groupsDescByRound as $round => $groups) {
            $previousRound = $this->getPreviousRound($round);
            foreach ($groups->reverse()->values() as $matchNumber => $group) {
                $parent = $this->getParentGroup($matchNumber + 1, $previousRound);
                $group->parent_id = $parent->id;
                $group->save();
            }
        }
    }

    /**
     * @param Collection $fighters
     * @param $frequency
     * @param $sizeGroupBy
     * @param $bye
     *
     * @return Collection
     */
    private function getFullFighterList(Collection $fighters, $frequency, $sizeGroupBy, $bye): Collection
    {
        $newFighters = new Collection();
        $count = 0;
        $byeCount = 0;
        foreach ($fighters as $fighter) {
            if ($this->shouldInsertBye($frequency, $sizeGroupBy, $count, $byeCount)) {
                $newFighters->push($bye);
                $byeCount++;
            }
            $newFighters->push($fighter);
            $count++;
        }

        return $newFighters;
    }

    /**
     * @param $frequency
     * @param $sizeGroupBy
     * @param $count
     * @param $byeCount
     *
     * @return bool
     */
    private function shouldInsertBye($frequency, $sizeGroupBy, $count, $byeCount): bool
    {
        return $frequency != -1 && $count % $frequency == 0 && $byeCount < $sizeGroupBy;
    }

    /**
     * Destroy Previous Fights for demo.
     */
    protected function destroyPreviousFights()
    {
        // Delete previous fight for this championship
        $arrGroupsId = $this->championship->fightersGroups()->get()->pluck('id');
        Fight::destroy($arrGroupsId);
    }

    /**
     * Generate Fights for next rounds.
     */
    public function generateNextRoundsFights()
    {
        $fightersCount = $this->championship->competitors->count() + $this->championship->teams->count();
        $maxRounds = $this->getNumRounds($fightersCount);
        for ($numRound = 1; $numRound < $maxRounds; $numRound++) {
            $groupsByRound = $this->championship->fightersGroups()->where('round', $numRound)->with('parent', 'children')->get();
            $this->updateParentFight($groupsByRound); // should be groupsByRound
        }
    }

    /**
     * @param $groupsByRound
     */
    protected function updateParentFight($groupsByRound)
    {
        foreach ($groupsByRound as $keyGroup => $group) {
            $parentGroup = $group->parent;
            if ($parentGroup == null) {
                break;
            }
            $parentFight = $parentGroup->fights->get(0);

            // determine whether c1 or c2 must be updated
            $this->chooseAndUpdateParentFight($keyGroup, $group, $parentFight);
        }
    }

    /**
     * @param $group
     * @param $parentFight
     */
    protected function chooseAndUpdateParentFight($keyGroup, FightersGroup $group, Fight $parentFight)
    {
        // we need to know if the child has empty fighters, is this BYE or undetermined
        if ($group->hasDeterminedParent()) {
            $valueToUpdate = $group->getValueToUpdate(); // This should be OK
            if ($valueToUpdate != null) {
                $fighterToUpdate = $group->getParentFighterToUpdate($keyGroup);
                $parentFight->$fighterToUpdate = $valueToUpdate;
                $parentFight->save();
                // Add fighter to pivot table
                $parentGroup = $parentFight->group;

                $fighter = $this->getFighter($valueToUpdate);
                $this->addFighterToGroup($parentGroup, $fighter);
            }
        }
    }

    /**
     * Calculate the area of the group ( group is still not created ).
     *
     * @param $round
     * @param $order
     *
     * @return int
     */
    protected function getNumArea($round, $order)
    {
        $totalAreas = $this->settings->fightingAreas;
        $numFighters = $this->championship->fighters->count(); // 4
        $numGroups = $this->getTreeSize($numFighters, $this->championship->getGroupSize()) / $this->championship->getGroupSize(); // 1 -> 1

50% of this comment could be valid code. Did you maybe forget this after debugging?

        $areaSize = $numGroups / ($totalAreas * pow(2, $round - 1));

        $numArea = intval(ceil($order / $areaSize)); // if round == 4, and second match 2/2 = 1 BAD
//        dump($numArea);
        return $numArea;
    }


    protected function generateAllFights()
    {
        $this->generateFights(); // Abstract

        //TODO In direct elimination without Prelim, short_id are not generating well
        $this->generateNextRoundsFights();
        Fight::generateFightsId($this->championship);
    }

    /**
     * @param $winners
     * @param $numFighter
     * @param $fighters
     * @return int|null
     */
    protected function getWinnerId($winners, $numFighter, $fighters)
    {
        if ($winners[$numFighter] != null) {
            return $fighters[$numFighter];
        }
        return null;
    }

    /**
     * @param $fighters
     * @param $numFighter
     * @param $fight
     * @param $winners
     * @return int
     */
    protected function updateFight($fighters, $numFighter, $fight, $winners)
    {
        $fight->c1 = $fighters[$numFighter];
        $fight->winner_id = $this->getWinnerId($winners, $numFighter, $fighters);
        $fight->save();
        $numFighter++;

        $fight->c2 = $fighters[$numFighter];
        if ($fight->winner_id == null) {

It seems like you are loosely comparing $fight->winner_id of type integer|null against null; this is ambiguous if the integer can be zero. Consider using a strict comparison === instead.

            $fight->winner_id = $this->getWinnerId($winners, $numFighter, $fighters);
        }
        $fight->save();
        $numFighter++;
        return $numFighter;
    }
}