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: Achtel-, Viertel-, Halb-, Finale require additional leagues; Same with Pokal, so createMissingLeagues method will be needed in the future

            $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();

                    }
                }
            }
        }

        Match::createMissingMatchups();

        return redirect("/seasons");
    }

    public function showLeagueRounds($league_rank, $round_id) { // $round_id = $max_round_id
        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)->get();

        $matchesTotal = array();

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

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


}