auditionadmin/app/Http/Controllers/NominationEnsembles/MeobdaNominationAdminController.php

<?php

namespace App\Http\Controllers\NominationEnsembles;

use App\Http\Controllers\Controller;
use App\Models\NominationEnsemble;
use App\Models\NominationEnsembleEntry;
use App\Models\School;
use App\Models\Student;
use Illuminate\Validation\Rule;

use function redirect;

class MeobdaNominationAdminController extends Controller implements NominationAdminController
{
    public function index()
    {
        if (request('newFilterParameters')) {
            $newFilterData = request()->validate([
                'school' => 'nullable|exists:schools,id',
                'section' => 'nullable|string',
                'newFilterParameters' => 'string',
                'split' => 'nullable|string',
                'clear' => 'nullable|string',
            ]);
            if ($newFilterData['clear'] ?? false == 'clear') {
                $filterData = [];
                session()->forget('nominationAdminFilters');
            } else {
                session()->put('nominationAdminFilters', $newFilterData);
                $filterData = $newFilterData;
            }
        } elseif (session()->has('nominationAdminFilters')) {
            $filterData = session()->get('nominationAdminFilters');
        } else {
            $filterData = [];
        }

        // Populate variables to complete the filter form
        $schools = School::orderBy('name')->get();
        $ensembles = NominationEnsemble::all();
        $sections = [];
        $splits = [];
        foreach ($ensembles as $ensemble) {
            // Populate sections for each ensemble
            $sections[$ensemble->id.'---'.'all'] = $ensemble->name.' - ALL';
            foreach ($ensemble->data['instruments'] as $instrument) {
                $sections[$ensemble->id.'---'.$instrument['name']] = $ensemble->name.' - '.$instrument['name'];
            }

            // Populate splits for each ensemble
            $splits[$ensemble->id.'---'.'all'] = $ensemble->name.' - ALL';
            foreach ($ensemble->data['split_names'] as $splitName) {
                $splits[$ensemble->id.'---'.$splitName] = $ensemble->name.' - '.$splitName;
            }
        }

        // Get and filter nominations
        $nominations = NominationEnsembleEntry::with('student.school');
        if ($filterData['school'] ?? false) {
            $nominations = $nominations->whereHas('student', function ($query) use ($filterData) {
                $query->where('school_id', $filterData['school']);
            });
        }

        if ($filterData['section'] ?? false) {
            $sectionFilter = explode('---', $filterData['section']);
            $nominations = $nominations->where('nomination_ensemble_id', $sectionFilter[0]);
            if ($sectionFilter[1] != 'all') {
                $nominations = $nominations->where('data->instrument', $sectionFilter[1]);
            }
        }

        if ($filterData['split'] ?? false) {
            if ($filterData['split'] == 'NO-SPLIT-ASSIGNED') {
                $nominations = $nominations->whereNull('data->split');
            } else {
                $splitFilter = explode('---', $filterData['split']);
                $nominations = $nominations->where('nomination_ensemble_id', $splitFilter[0]);
                if ($splitFilter[1] != 'all') {
                    $nominations = $nominations->where('data->split', $splitFilter[1]);
                }
            }
        }

        // Sort
        $nominations = $nominations->orderBy('id', 'desc');

        $nominations = $nominations->paginate(50);

        return view('nomination_ensembles.meobda.admin.nominations',
            compact('nominations', 'schools', 'filterData', 'ensembles', 'sections', 'splits'));
    }

    public function show(NominationEnsembleEntry $nominationEnsembleEntry)
    {
        // TODO: Implement show() method.
    }

    public function create()
    {
        $target_ensemble = null;
        $instrumentation = null;
        $students = null;
        if (request()->get('ensemble')) {
            $validData = request()->validate([
                'ensemble' => 'nullable|exists:nomination_ensembles,id',
            ]);
            $target_ensemble = NominationEnsemble::find($validData['ensemble']);

            // Get viable students for entering
            $students = Student::where('grade', '<=', $target_ensemble->maximum_grade)
                ->where('grade', '>=', $target_ensemble->minimum_grade)
                ->with('school')
                ->join('schools', 'schools.id', '=', 'students.school_id')
                ->orderBy('schools.name', 'asc')
                ->orderBy('students.last_name', 'asc')
                ->orderBy('students.first_name', 'asc')
                ->get(['students.*']);

            // Remove students already nominated
            $nominated_student_ids = NominationEnsembleEntry::where('nomination_ensemble_id',
                $target_ensemble->id)->pluck('student_id')->all();

            $students = $students->reject(function ($student) use ($nominated_student_ids) {
                return in_array($student->id, $nominated_student_ids);
            });

            // Get current instrumentation of target ensemble
            $instrumentation = $this->get_ensemble_instrumentation($target_ensemble);
        }
        $ensembles = NominationEnsemble::all();

        return view('nomination_ensembles.meobda.admin.nomination-create',
            compact('ensembles', 'target_ensemble', 'students', 'instrumentation'));
    }

    public function store()
    {
        // Initial Validation
        $validData = request()->validate([
            'ensemble' => 'required|exists:nomination_ensembles,id',
            'student' => 'required|exists:students,id',
            'instrument' => 'required|string',
            'split' => 'nullable|string',
            'seat' => 'nullable|integer',
        ]);
        $proposed_ensemble = NominationEnsemble::find($validData['ensemble']);

        // Check if $validData['instrument'] is a valid instrument for the proposed ensemble
        $validInstruments = array_column($proposed_ensemble->data['instruments'], 'name');
        if (! in_array($validData['instrument'], $validInstruments)) {
            return redirect()->back()->with('error', 'Invalid Instrument Specified');
        }

        $data['instrument'] = $validData['instrument'];
        if ($validData['seat'] > 0) {
            $data['seat'] = $validData['seat'];
        }
        if ($validData['split'] != '---') {
            $data['split'] = $validData['split'];
            // Check if $validData['split'] is a valid split for the proposed ensemble
            $validSplits = $proposed_ensemble->data['splits'];
            if (! in_array($validData['split'], $validSplits)) {
                return redirect()->back()->with('error', 'Invalid Split Specified');
            }
        }
        $newNomination = NominationEnsembleEntry::make([
            'student_id' => $validData['student'],
            'nomination_ensemble_id' => $validData['ensemble'],
            'data' => $data,
        ]);
        $newNomination->save();

        return redirect()->route('nomination.admin.index')->with('success', 'New Nomination created');
    }

    public function edit(NominationEnsembleEntry $nominationEnsembleEntry)
    {
        $students = Student::with('school')->get()
            ->sortBy('school.name');

        if (! isset($nominationEnsembleEntry->data['seat'])) {
            $data = $nominationEnsembleEntry->data;
            $data['seat'] = null;
            $nominationEnsembleEntry->data = $data;
        }

        $instrumentation = $this->get_ensemble_instrumentation($nominationEnsembleEntry->ensemble);

        return view('nomination_ensembles.meobda.admin.nomination-edit',
            compact('nominationEnsembleEntry', 'students', 'instrumentation'));
    }

    public function update(NominationEnsembleEntry $nominationEnsembleEntry)
    {
        $ensemble = $nominationEnsembleEntry->ensemble;
        $validSplits = $ensemble->data['split_names'];
        $validInstruments = [];
        foreach ($ensemble->data['instruments'] as $instrument) {
            $validInstruments[] = $instrument['name'];
        }
        $validData = request()->validate([
            'instrument' => ['nullable', Rule::in($validInstruments)],
            'split' => ['nullable', Rule::in($validSplits)],
            'seat' => ['nullable', 'integer'],
        ]);
        $data = $nominationEnsembleEntry->data;
        $data['instrument'] = $validData['instrument'];
        $data['split'] = $validData['split'];
        $data['seat'] = $validData['seat'];
        $nominationEnsembleEntry->update([
            'data' => $data,
        ]);

        return redirect()->route('nomination.admin.index')->with('success', 'Nomination updated');
    }

    public function destroy(NominationEnsembleEntry $nominationEnsembleEntry)
    {
        // TODO: Implement destroy() method.
    }

    private function get_ensemble_instrumentation(NominationEnsemble $ensemble)
    {
        $entries = NominationEnsembleEntry::where('nomination_ensemble_id', $ensemble->id)->get();
        $splits = $ensemble->data['split_names'];
        $instruments = [];
        foreach ($ensemble->data['instruments'] as $instrument) {
            $instruments[] = $instrument['name'];
        }
        $counts = [];
        foreach ($splits as $split) {
            $counts[$split] = [];
            foreach ($instruments as $instrument) {
                $counts[$split][$instrument] = 0;
            }
        }

        foreach ($entries as $entry) {
            if (! isset($entry->data['split'])) {
                continue;
            }
            $counts[$entry->data['split']][$entry->data['instrument']] += 1;
        }

        return $counts;
    }
}