tippspiel/pfosten/app/Http/Controllers/Leagues/LeaguesController.php

<?php

namespace App\Http\Controllers\Leagues;

use Illuminate\Http\Request;

use App\Http\Controllers\Controller;
use App\Http\Controllers\Leagues;


use Auth;
use App\Season;
use App\Round;
use App\User;

use App\Leagues\League;
use App\Leagues\LeagueMember;
use App\Leagues\Match;

use Log;
use DB;

class LeaguesController extends Controller
{
    public function index() {
        $season=Season::getCurrent();

        if (Auth::guest()) { return redirect("/"); }
        if (!Auth::user()->admin) { return redirect("/"); }

        $season = Season::where('id','=',$season->id)->first();
        if (!$season) return redirect("/seasons");

        $start_round_name="Einstellen";

        $rounds = Round::where('season_id','=',$season->id)->orderBy('id')->get();
        if (!$rounds) return redirect("/seasons");

        $round_count = 18;
        $start_round_name="Einstellen";
        $start_round_id=$rounds[0]->id;
        $league_mode="Einstellen";

        $league = League::where('season_id','=',$season->id)->first();
        if ($league) {
            $startround = Round::where('season_id', '=', $season->id)->orderBy('id')->first();
            $start_round_id = $startround->id;

            $startRound = Round::where('id','=',$league->start_round_id)->first();
            $start_round_name = $startRound->name;
            $start_round_id = $startRound->id;
            $round_count = $league->round_count;
            if($league->is_qualification) { $league_mode="Qualifikation"; } else { $league_mode="Liga-Spiel"; }
        }

        // Fetch existing leagues

        // No leagues: Create Qualification League or Standard League System (including matches)
        // necessary input: start_round(_id), round_count

        // Delete all leagues & matches

        //

        return view('leagues.index', compact('season','rounds','start_round_id','start_round_name','league_mode','round_count'));
    }

    public function createLeagues($start_round_id, $round_count, $league_mode) {
        $currentSeason=Season::getCurrent();

        // Eventuell vorhandene Ligen loeschen
        $leagues=League::where('season_id','=',$currentSeason->id)->get();
        if ($leagues) {
            foreach ($leagues as $league) {
                DB::table('leagues_matches')->where('league_id', '=', $league->id)->delete();
                DB::table('leagues_members')->where('league_id', '=', $league->id)->delete();
                DB::table('leagues')->where('id', '=', $league->id)->delete();
            }
        }

        $active_member_count=sizeof(User::getActives());
        Log::info("Aktive Spieler: ".$active_member_count);
        $neededLeagues = League::neededLeagues($active_member_count, $round_count);
        Log::info("Benötigte Quali-Gruppen: ".$neededLeagues);

        $league_ids=array();
        Log::info("League Mode:".$league_mode);

        if ($league_mode=="Qualifikation") {
            for ($league_nr=1; $league_nr<=$neededLeagues; $league_nr+=1) {
                $league = League::create([
                    'is_qualification' => true,
                    'name' => 'Qualifikationsgruppe '.$league_nr,
                    'rank' => '4',
                    'subrank' => $league_nr,
                    'round_count' => $round_count,
                    'season_id' => $currentSeason->id,
                    'start_round_id' => $start_round_id
                ]);
                $league->save();
                $league_ids[$league_nr-1] = $league->id;
            }

            // Distribute members
            $users = User::getActives();
            shuffle($users);
            $league_index=0;
            Log::info("Distributing Members between groups");
            while(sizeof($users)>0) {
                $user = array_pop($users);

                $leagueMember = LeagueMember::create([
                    'user_id'   => $user->id,
                    'league_id' => $league_ids[$league_index]
                ]);
                $leagueMember->save();

                $league_index+=1;
                if (sizeof($league_ids)==$league_index) { $league_index=0; }
            }

        } else {

            // ToDo: Branch Qualifikation/Liga entfällt in Zukunft, da Quali der Fallback für den Fall ist, dass keine vorherige Saison existiert.
            // Pokal und Play-Off findet hier nicht statt, da diese Wettbewerbe die Matches abgängig von existierenden Vorrunden-Ergebnissen erzeugen,
            // und daher zwangsläufig inkrementell sein müssen.

            $league_size1= min(22,$active_member_count);
            $league1 = League::create([
                'is_qualification' => false,
                'name' => 'Spielerliga 1',
                'rank' => '1',
                'subrank' => '1',
                'round_count' => $round_count,
                'season_id' => $currentSeason->id,
                'start_round_id' => $start_round_id
            ]);

            $league_size2=min(22,$active_member_count - $league_size1);

            if ($league_size2>0) {
                $league2 = League::create([
                    'is_qualification' => false,
                    'name' => 'Spielerliga 2',
                    'rank' => '2',
                    'subrank' => '1',
                    'round_count' => $round_count,
                    'season_id' => $currentSeason->id,
                    'start_round_id' => $start_round_id
                ]);

                $league_size3 = $active_member_count - $league_size1 - $league_size2;

                if ($league_size3>0) {
                    $neededLeagues = League::neededLeagues($league_size3, $round_count);
                    for ($league_nr=1; $league_nr<=$neededLeagues; $league_nr+=1) {
                        $league = League::create([
                            'is_qualification' => false,
                            'name' => 'Spielerliga 3, Gruppe '.$league_nr,
                            'rank' => '3',
                            'subrank' => $league_nr,
                            'round_count' => $round_count,
                            'season_id' => $currentSeason->id,
                            'start_round_id' => $start_round_id
                        ]);
                        $league->save();

                    }
                }

                // TODO: LeagueMembers zu den Leagues hinzufügen, abhängig vom zuzuordnenden Platz

            }
        }

        Match::createMatchups();

        return redirect("/seasons");
    }

    public function showLeagueRounds($league_rank) {
        if (Auth::guest()) { return redirect("/"); }

        $season=Season::getCurrent();

        $roundNames = Round::getNames();
        $leagueNames = League::getNames();
        $leagues = League::where('season_id','=',$season->id)->where('rank','=', $league_rank)->orderBy('id')->get();
        $matchesTotal = array();

        foreach ($leagues as $league) {
            $matches = Match::getMatchResults($league->id, -1);
            foreach ($matches as $match) {
                if (!key_exists($match->round_id, $matchesTotal)) {
                    $matchesTotal[$match->round_id]=array();
                }
                if (!key_exists($league->id, $matchesTotal[$match->round_id] )) {
                    $matchesTotal[$match->round_id][$league->id]=array();
                }
                $lg = $matchesTotal[$match->round_id][$league->id];
                array_push($lg, $match);
                $matchesTotal[$match->round_id][$league->id] = $lg;
            }
        }

        return view ('leagues.matches', compact('season', 'matchesTotal','leagues','leagueNames','roundNames'));
    }

    public static function showLeagueRanking($rank, $maxRoundId=-1) {
        $season = Season::getCurrent();
        $leagues = array_reverse(League::getRanking($rank));
        $leagueNames = League::getNames();
        $userNames = User::getNames();

        $leagueScores = League::getRanking($rank);
        return view ('leagues.chart',compact('season','leagues', 'leagueNames', 'userNames','leagueScores'));
    }

    public static function showSingleUserMatches($userId) {
        $season = Season::getCurrent();
        $leagueNames = League::getNames();
        $roundNames = Round::getNames();
        $matches =  Match::getMatchResultsForUser($userId);

        $user = User::where('id','=', $userId)->first();
        $userName = $user->name;
        return view ('leagues.playermatches',compact('season','leagueNames','roundNames','matches','userName'));
    }

}