Xoco70\LaravelTournaments\Models\Fight

Complexity

Total Complexity

37

Size/Duplication

Total Lines	240
Duplicated Lines	0 %

Coupling/Cohesion

Components	4
Dependencies	3

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	group()	0	4	1
A	getFightersWithByes()	0	16	4
A	competitor1()	0	4	1
A	competitor2()	0	4	1
A	team1()	0	4	1
A	team2()	0	4	1
A	fighter1()	0	6	2
A	fighter2()	0	6	2
B	getFighterAttr()	0	18	5
B	shouldBeInFightList()	0	22	6
A	has2Fighters()	0	4	2
A	belongsToFirstRound()	0	9	2
A	dontHave2Fighters()	0	4	2
A	dontHave0Fighters()	0	4	2
A	generateFightsId()	0	7	2
A	updateShortId()	0	11	2

<?php

namespace Xoco70\LaravelTournaments\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Collection;

class Fight extends Model
{
    /**
     * Fight constructor.
     *
     * @param int $userId1
     * @param int $userId2
     */
    public function __construct($userId1 = null, $userId2 = null)
    {
        parent::__construct();
        $this->c1 = $userId1;
        $this->c2 = $userId2;
    }

    protected $table = 'fight';
    public $timestamps = true;

    protected $fillable = [
        'group_id',
        'fight_id',
        'c1',
        'c2',
    ];

    /**
     * Get First Fighter.
     *
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function group()
    {
        return $this->belongsTo(FightersGroup::class, 'fighters_group_id');
    }

    /**
     * @param FightersGroup|null $group
     *
     * @return Collection
     */
    protected static function getFightersWithByes(FightersGroup $group)
    {
        if ($group == null) {
            return null;
        }
        $fighters = $group->getFightersWithBye();
        $fighterType = $group->getFighterType();
        if (count($fighters) == 0) {
            $fighters->push(new $fighterType());
            $fighters->push(new $fighterType());
        } elseif (count($fighters) % 2 != 0) {
            $fighters->push(new $fighterType());
        }

        return $fighters;
    }

    /**
     * Get First Fighter.
     *
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function competitor1()
    {
        return $this->belongsTo(Competitor::class, 'c1', 'id');
    }

    /**
     * Get Second Fighter.
     *
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function competitor2()
    {
        return $this->belongsTo(Competitor::class, 'c2', 'id');
    }

    /**
     * Get First Fighter.
     *
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function team1()
    {
        return $this->belongsTo(Team::class, 'c1', 'id');
    }


    /**
     * Get Second Fighter.
     *
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function team2()
    {
        return $this->belongsTo(Team::class, 'c2', 'id');
    }

    /**
     * Get First Fighter.
     *
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function fighter1()
    {
        return $this->group->championship->category->isTeam
            ? $this->team1()
            : $this->competitor1();
    }

    /**
     * Get First Fighter.
     *
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function fighter2()
    {
        return $this->group->championship->category->isTeam
            ? $this->team2()
            : $this->competitor2();
    }

    /**
     * @param $numFighter
     * @param $attr
     *
     * @return null|string
     */
    public function getFighterAttr($numFighter, $attr)
    {
        $isTeam = $this->group->championship->category->isTeam;
        if ($isTeam) {
            $teamToUpdate = 'team' . $numFighter;

            return optional($this->$teamToUpdate)->$attr;
        }
        $competitorToUpdate = 'competitor' . $numFighter;
        if ($attr == 'name') {
            return $this->$competitorToUpdate == null
                ? ''
                : $this->$competitorToUpdate->user->firstname . ' ' . $this->$competitorToUpdate->user->lastname;
        } elseif ($attr == 'short_id') {
            return optional($this->$competitorToUpdate)->short_id;
        }
        return null;
    }

    /**
     * @return bool
     */
    public function shouldBeInFightList($default)
    {
        if ($this->belongsToFirstRound() && $this->dontHave2Fighters()) {
            return false;
        }
        if (!$this->belongsToFirstRound() && $this->dontHave0Fighters()) {
            return true;
        }
        if ($this->has2Fighters()) {
            return true;
        }
        // We aint in the first round, and there is 1 or 0 competitor
        // We check children, and see :
        // if there is 2  - 2 fighters -> undetermine, we cannot add it to fight list
        // if there is 2  - 1 fighters -> undetermine, we cannot add it to fight list
        // if there is 2  - 0 fighters -> undetermine, we cannot add it to fight list
        // if there is 1  - 2 fighters -> undetermine, we cannot add it to fight list
        // if there is 1  - 1 fighters -> fight should have 2 fighters, undetermines
        // if there is 1  - 0 fighters -> determined, fight should not be in the list
        // if there is 0  - 1 fighters -> determined, fight should not be in the list
        return $default;
    }

    /**
     * return true if fight has 2 fighters ( No BYE ).
     *
     * @return bool
     */
    public function has2Fighters(): bool
    {
        return $this->c1 != null && $this->c2 != null;
    }

    /**
     * @return bool
     */
    private function belongsToFirstRound(): bool
    {
        $firstRoundFights = $this->group->championship->firstRoundFights->pluck('id')->toArray();
        if (in_array($this->id, $firstRoundFights)) {
            return true;
        }

        return false;
    }

    /**
     * @return bool
     */
    private function dontHave2Fighters()
    {
        return $this->c1 == null || $this->c2 == null;
    }

    /**
     * @return bool
     */
    private function dontHave0Fighters()
    {
        return $this->c1 != null || $this->c2 != null;
    }

    /**
     * @param Championship $championship
     */
    public static function generateFightsId(Championship $championship)
    {
        $order = 1;
        foreach ($championship->fights as $fight) {
            $order = $fight->updateShortId($order);
        }
    }

    /**
     * @param $order
     *
     * @return int
     */
    public function updateShortId($order)
    {
        if ($this->shouldBeInFightList(false)) {
            $this->short_id = $order;
            $this->save();

            return ++$order;
        }

        return $order;
    }
}