ladill-meet/app/Http/Controllers/Meet/JoinController.php

<?php

namespace App\Http\Controllers\Meet;

use App\Http\Controllers\Controller;
use App\Models\Room;
use App\Services\Meet\InvitationService;
use App\Services\Meet\SecurityPolicyService;
use App\Services\Meet\SessionService;
use App\Services\Meet\WebinarService;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Validation\ValidationException;
use Illuminate\View\View;

class JoinController extends Controller
{
    public function __construct(
        protected SessionService $sessions,
        protected SecurityPolicyService $security,
        protected WebinarService $webinars,
    ) {}

    public function show(Request $request, Room $room): View|RedirectResponse
    {
        if ($room->status === 'cancelled') {
            return view('meet.join.cancelled', compact('room'));
        }

        if ($room->isWebinar() && $request->query('token')) {
            $request->session()->put("meet.webinar.{$room->uuid}", $request->query('token'));
        }

        [$allowed, $reason] = $this->security->canJoin($room, $request->user(), $request->user()?->email);
        if (! $allowed && $reason !== 'passcode_required') {
            return view('meet.join.denied', compact('room', 'reason'));
        }

        if ($room->passcode && ! $request->session()->get("meet.passcode.{$room->uuid}")) {
            return view('meet.join.passcode', compact('room'));
        }

        return view('meet.join.show', [
            'room' => $room,
            'user' => $request->user(),
            'isWebinar' => $room->isWebinar(),
        ]);
    }

    public function verifyPasscode(Request $request, Room $room): RedirectResponse
    {
        $request->validate(['passcode' => ['required', 'string']]);

        if ($room->passcode !== $request->input('passcode')) {
            return back()->withErrors(['passcode' => 'Incorrect passcode.']);
        }

        $request->session()->put("meet.passcode.{$room->uuid}", true);

        return redirect()->route('meet.join', $room);
    }

    public function enter(Request $request, Room $room): RedirectResponse
    {
        if ($room->passcode && ! $request->session()->get("meet.passcode.{$room->uuid}")) {
            return redirect()->route('meet.join', $room);
        }

        $rules = [
            'email' => ['nullable', 'email'],
        ];

        if ($request->user()) {
            $rules['display_name'] = ['nullable', 'string', 'max:100'];
        } else {
            $rules['display_name'] = ['required', 'string', 'max:100'];
        }

        try {
            $validated = $request->validate($rules);
        } catch (ValidationException $e) {
            throw $e->redirectTo(route('meet.join', $room));
        }

        $user = $request->user();
        $displayName = $user?->name ?? ($validated['display_name'] ?? 'Guest');
        $email = $user?->email ?? ($validated['email'] ?? null);

        [$allowed, $reason] = $this->security->canJoin($room, $user, $email ?? $displayName.'@guest.local');
        if (! $allowed && $reason !== 'passcode_required') {
            return back()->withErrors(['join' => $reason ?? 'Unable to join meeting.']);
        }

        if ($room->isLive() && $room->activeSession()) {
            $session = $room->activeSession();
        } elseif ($room->isTownHall() && $user && $user->ownerRef() === $room->host_user_ref && $room->setting('green_room')) {
            $session = app(\App\Services\Meet\TownHallService::class)->startGreenRoom($room, $user);
        } elseif ($user && $user->ownerRef() === $room->host_user_ref) {
            $session = $this->sessions->start($room, $user);
        } elseif ($room->setting('join_before_host') || ($user && $user->ownerRef() === $room->host_user_ref)) {
            if (! $room->activeSession() && $user && $user->ownerRef() === $room->host_user_ref) {
                $session = $this->sessions->start($room, $user);
            } elseif (! $room->activeSession()) {
                return back()->withErrors(['join' => 'Meeting has not started yet. Please wait for the host.']);
            } else {
                $session = $room->activeSession();
            }
        } else {
            if (! $room->activeSession()) {
                return back()->withErrors(['join' => 'Meeting has not started yet. Please wait for the host.']);
            }

            $session = $room->activeSession();
        }

        $role = ($user && $user->ownerRef() === $room->host_user_ref) ? 'host' : 'guest';

        if ($room->isWebinar() && $role !== 'host') {
            $token = $request->session()->get("meet.webinar.{$room->uuid}");
            $reg = $token
                ? $this->webinars->findByAccessToken($token)
                : ($email ? $this->webinars->findApprovedRegistration($room, $email) : null);

            if (! $reg) {
                return redirect()->route('meet.webinar.register', $room)
                    ->withErrors(['register' => 'Approved registration is required for this webinar.']);
            }

            $role = 'attendee';
            $displayName = $reg->display_name;
        }

        $participant = $this->sessions->joinParticipant($session, $user, $role, $displayName, $email);

        app(InvitationService::class)->markAcceptedOnJoin($room, $user, $email);

        $this->sessions->rememberParticipantSession($request, $participant, $session);

        return redirect()->route('meet.room', $session);
    }
}