<?php

namespace App\Http\Controllers\Care;

use App\Http\Controllers\Care\Concerns\ScopesToAccount;
use App\Http\Controllers\Controller;
use App\Models\Appointment;
use App\Models\Department;
use App\Models\InvestigationType;
use App\Models\PatientAttachment;
use App\Models\Visit;
use App\Services\Care\AppointmentService;
use App\Services\Care\CareQueueBridge;
use App\Services\Care\CareQueueSessionAdvance;
use App\Services\Care\ConsultationService;
use App\Services\Care\OrganizationResolver;
use App\Services\Care\SpecialtyClinicalRecordService;
use App\Services\Care\SpecialtyModuleService;
use App\Services\Care\SpecialtyShellService;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\View\View;

class SpecialtyModuleController extends Controller
{
    use ScopesToAccount;

    public function show(
        Request $request,
        string $module,
        SpecialtyModuleService $modules,
        SpecialtyShellService $shell,
        CareQueueBridge $queueBridge,
    ): RedirectResponse {
        $definition = $modules->definition($module);
        abort_unless($definition, 404);
        abort_unless(
            $modules->memberCanAccess($this->organization($request), $this->member($request), $module),
            403,
        );

        // Specialty patient flow lives on Queue; clinical depth opens from Queue Start.
        return redirect()->route('care.queue.index');
    }

    public function visits(
        Request $request,
        string $module,
        SpecialtyModuleService $modules,
        SpecialtyShellService $shell,
        CareQueueBridge $queueBridge,
    ): RedirectResponse {
        $definition = $modules->definition($module);
        abort_unless($definition, 404);
        abort_unless(
            $modules->memberCanAccess($this->organization($request), $this->member($request), $module),
            403,
        );

        return redirect()->route('care.queue.index');
    }

    public function history(
        Request $request,
        string $module,
        SpecialtyModuleService $modules,
        SpecialtyShellService $shell,
        CareQueueBridge $queueBridge,
    ): View {
        return $this->renderShell($request, $module, 'history', $modules, $shell, $queueBridge);
    }

    public function billing(
        Request $request,
        string $module,
        SpecialtyModuleService $modules,
        SpecialtyShellService $shell,
        CareQueueBridge $queueBridge,
    ): View {
        return $this->renderShell($request, $module, 'billing', $modules, $shell, $queueBridge);
    }

    public function workspace(
        Request $request,
        string $module,
        SpecialtyModuleService $modules,
        SpecialtyShellService $shell,
        CareQueueBridge $queueBridge,
        ?Visit $visit = null,
    ): View {
        return $this->renderShell($request, $module, 'workspace', $modules, $shell, $queueBridge, $visit);
    }

    public function addService(
        Request $request,
        string $module,
        Visit $visit,
        SpecialtyModuleService $modules,
        SpecialtyShellService $shell,
    ): RedirectResponse {
        $definition = $modules->definition($module);
        abort_unless($definition, 404);

        $organization = $this->organization($request);
        $member = $this->member($request);
        abort_unless($modules->memberCanAccess($organization, $member, $module), 403);
        abort_unless($modules->memberCanManage($organization, $member, $module), 403);
        abort_unless($visit->organization_id === $organization->id, 404);

        $validated = $request->validate([
            'service_code' => ['required', 'string', 'max:64'],
        ]);

        try {
            $bill = $shell->addCatalogServiceToVisit(
                $organization,
                $visit,
                $module,
                $validated['service_code'],
                $this->ownerRef($request),
                $this->ownerRef($request),
            );
        } catch (\Throwable $e) {
            return back()->with('error', $e->getMessage());
        }

        return back()->with('success', 'Added to invoice '.$bill->invoice_number.'.');
    }

    public function startConsultation(
        Request $request,
        string $module,
        Visit $visit,
        SpecialtyModuleService $modules,
        AppointmentService $appointments,
        ConsultationService $consultations,
    ): RedirectResponse {
        $this->authorizeAbility($request, 'consultations.manage');

        $definition = $modules->definition($module);
        abort_unless($definition, 404);

        $organization = $this->organization($request);
        $member = $this->member($request);
        abort_unless($modules->memberCanAccess($organization, $member, $module), 403);
        abort_unless($modules->memberCanManage($organization, $member, $module), 403);
        abort_unless($visit->organization_id === $organization->id, 404);
        $this->authorizeBranch($request, (int) $visit->branch_id);

        $visit->loadMissing(['appointment.consultation', 'appointment.practitioner']);
        $appointment = $visit->appointment;
        if (! $appointment || $appointment->organization_id !== $organization->id) {
            return back()->with('error', 'This visit has no appointment to start a consultation from.');
        }

        $owner = $this->ownerRef($request);
        $openConsultation = $appointment->consultation;
        if ($openConsultation && $openConsultation->status !== \App\Models\Consultation::STATUS_COMPLETED) {
            $clinical = app(SpecialtyClinicalRecordService::class);
            $shellTabs = app(SpecialtyShellService::class)->workspaceTabs($module);
            $preferredTab = match ($module) {
                'dentistry' => 'odontogram',
                'emergency' => 'triage',
                default => (collect(array_keys($shellTabs))
                    ->first(fn (string $tab) => $clinical->recordTypeForTab($module, $tab) !== null)
                    ?? 'clinical_notes'),
            };

            return redirect()
                ->route('care.specialty.workspace', [
                    'module' => $module,
                    'visit' => $visit,
                    'tab' => $preferredTab,
                ])
                ->with('success', 'Encounter already in progress.');
        }

        try {
            if (in_array($appointment->status, [
                Appointment::STATUS_WAITING,
                Appointment::STATUS_CHECKED_IN,
            ], true)) {
                $appointments->startConsultation(
                    $appointment,
                    $owner,
                    $appointment->practitioner_id,
                    $owner,
                );
                $appointment = $appointment->fresh(['practitioner', 'visit']);
            } elseif ($appointment->status !== Appointment::STATUS_IN_CONSULTATION) {
                return back()->with('error', 'This appointment cannot start a consultation from its current status.');
            }

            $consultations->startFromAppointment(
                $appointment,
                $owner,
                $owner,
            );
        } catch (\InvalidArgumentException $e) {
            return back()->with('error', $e->getMessage());
        }

        $visit = $visit->fresh() ?? $appointment->visit;
        if ($visit) {
            $stageService = app(\App\Services\Care\SpecialtyVisitStageService::class);
            $nextStage = $stageService->stageOnConsultationStart($module);
            if ($nextStage && ! $visit->specialty_stage) {
                try {
                    $stageService->setStage(
                        $organization,
                        $visit,
                        $module,
                        $nextStage,
                        $owner,
                        $owner,
                    );
                    $visit = $visit->fresh();
                } catch (\InvalidArgumentException) {
                    // Stage map may be empty for some modules.
                }
            } elseif ($nextStage && in_array($visit->specialty_stage, ['waiting', 'arrival'], true)) {
                try {
                    $stageService->setStage($organization, $visit, $module, $nextStage, $owner, $owner);
                    $visit = $visit->fresh();
                } catch (\InvalidArgumentException) {
                }
            }
        }
        $clinical = app(SpecialtyClinicalRecordService::class);
        $shellTabs = app(SpecialtyShellService::class)->workspaceTabs($module);
        $preferredTab = match ($module) {
            'dentistry' => 'odontogram',
            'emergency' => 'triage',
            default => (collect(array_keys($shellTabs))
                ->first(fn (string $tab) => $clinical->recordTypeForTab($module, $tab) !== null)
                ?? 'clinical_notes'),
        };

        return redirect()
            ->route('care.specialty.workspace', [
                'module' => $module,
                'visit' => $visit,
                'tab' => $preferredTab,
            ])
            ->with('success', 'Encounter started.');
    }

    public function saveClinical(
        Request $request,
        string $module,
        Visit $visit,
        SpecialtyModuleService $modules,
        SpecialtyClinicalRecordService $clinical,
    ): RedirectResponse {
        $definition = $modules->definition($module);
        abort_unless($definition, 404);

        $organization = $this->organization($request);
        $member = $this->member($request);
        abort_unless($modules->memberCanAccess($organization, $member, $module), 403);
        abort_unless($modules->memberCanManage($organization, $member, $module), 403);
        abort_unless($visit->organization_id === $organization->id, 404);

        $tab = (string) $request->input('tab', '');
        $recordType = $clinical->recordTypeForTab($module, $tab);
        abort_unless($recordType, 422);

        // Normalize checkbox booleans before validation.
        $payload = (array) $request->input('payload', []);
        foreach ($clinical->fieldsFor($module, $recordType) as $field) {
            if (($field['type'] ?? '') === 'boolean') {
                $payload[$field['name']] = $request->boolean('payload.'.$field['name']);
            }
        }
        $request->merge(['payload' => $payload]);

        $validated = $request->validate(array_merge([
            'tab' => ['required', 'string'],
            'stage_code' => ['nullable', 'string', 'max:64'],
            'status' => ['nullable', 'in:draft,active,completed'],
        ], $clinical->validationRules($module, $recordType)));

        $record = $clinical->upsert(
            $organization,
            $visit,
            $module,
            $recordType,
            $clinical->payloadFromRequest($validated),
            $this->ownerRef($request),
            $this->ownerRef($request),
            $validated['stage_code'] ?? null,
            $validated['status'] ?? \App\Models\SpecialtyClinicalRecord::STATUS_ACTIVE,
        );

        if ($module === 'emergency' && $recordType === 'triage') {
            $workflow = app(\App\Services\Care\Emergency\EmergencyWorkflowService::class);
            $stageService = app(\App\Services\Care\SpecialtyVisitStageService::class);
            $suggested = $workflow->stageFromTriage($record->payload ?? []);
            $current = $visit->specialty_stage;
            if (! $current || in_array($current, ['arrival', 'waiting'], true)) {
                try {
                    $stageService->setStage(
                        $organization,
                        $visit,
                        'emergency',
                        $suggested,
                        $this->ownerRef($request),
                        $this->ownerRef($request),
                    );
                } catch (\InvalidArgumentException) {
                }
            }
        }

        if ($module === 'emergency' && $recordType === 'observation') {
            $stageService = app(\App\Services\Care\SpecialtyVisitStageService::class);
            try {
                $stageService->setStage(
                    $organization,
                    $visit,
                    'emergency',
                    \App\Services\Care\Emergency\EmergencyWorkflowService::STAGE_OBSERVATION,
                    $this->ownerRef($request),
                    $this->ownerRef($request),
                );
            } catch (\InvalidArgumentException) {
            }
        }

        return redirect()
            ->route('care.specialty.workspace', [
                'module' => $module,
                'visit' => $visit,
                'tab' => $tab,
            ])
            ->with('success', 'Saved '.$record->record_type.' record.');
    }

    public function uploadDocument(
        Request $request,
        string $module,
        Visit $visit,
        SpecialtyModuleService $modules,
    ): RedirectResponse {
        $definition = $modules->definition($module);
        abort_unless($definition, 404);

        $organization = $this->organization($request);
        $member = $this->member($request);
        // Viewing docs is workspace GET (memberCanAccess / memberCanView). Upload needs manage.
        abort_unless($modules->memberCanAccess($organization, $member, $module), 403);
        abort_unless($modules->memberCanManage($organization, $member, $module), 403);
        abort_unless($visit->organization_id === $organization->id, 404);
        abort_unless($visit->patient_id, 422);

        $validated = $request->validate([
            'attachment' => ['required', 'file', 'max:10240', 'mimes:pdf,jpeg,jpg,png,webp'],
        ]);

        $file = $validated['attachment'];
        $path = $file->store("care/patients/{$visit->patient_id}/attachments", 'public');

        PatientAttachment::create([
            'owner_ref' => $this->ownerRef($request),
            'patient_id' => $visit->patient_id,
            'file_path' => $path,
            'original_name' => $file->getClientOriginalName(),
            'mime_type' => $file->getMimeType(),
            'document_type' => 'specialty_'.$module,
            'uploaded_by' => $this->ownerRef($request),
        ]);

        return redirect()
            ->route('care.specialty.workspace', [
                'module' => $module,
                'visit' => $visit,
                'tab' => 'documents',
            ])
            ->with('success', 'Document uploaded.');
    }

    public function callNext(
        Request $request,
        string $module,
        SpecialtyModuleService $modules,
        CareQueueBridge $queueBridge,
        CareQueueSessionAdvance $advance,
    ): RedirectResponse {
        $definition = $modules->definition($module);
        abort_unless($definition, 404);

        $organization = $this->organization($request);
        $member = $this->member($request);
        $owner = $this->ownerRef($request);
        abort_unless($modules->memberCanAccess($organization, $member, $module), 403);
        abort_unless($modules->memberCanManage($organization, $member, $module), 403);
        abort_unless($queueBridge->isEnabled($organization), 404);

        $resolver = app(OrganizationResolver::class);
        $branchScope = $resolver->branchScope($member);
        $practitionerScope = $resolver->practitionerScope($organization, $member);
        $branchId = (int) ($request->input('branch_id') ?: $branchScope);
        $practitionerId = null;

        if ($practitionerScope !== null) {
            abort_unless($practitionerScope !== [], 422);
            $practitionerId = $practitionerScope[0];
            $pracBranch = (int) \App\Models\Practitioner::owned($owner)
                ->whereKey($practitionerId)
                ->value('branch_id');
            if ($pracBranch > 0) {
                $branchId = $pracBranch;
            }
        }

        abort_unless($branchId > 0, 422);

        if ($request->filled('appointment_id')) {
            $current = Appointment::owned($owner)
                ->where('organization_id', $organization->id)
                ->findOrFail((int) $request->input('appointment_id'));
            $advance->endCurrentEncounter($current, $owner, $owner);
        }

        $result = $queueBridge->callNext($organization, $module, $branchId, $member, $practitionerId);
        $ticket = $result['ticket'] ?? null;
        if (! $ticket) {
            $departmentIds = Department::owned($owner)
                ->where('type', $definition['department_type'] ?? 'general')
                ->where('is_active', true)
                ->when($branchScope, fn ($q) => $q->where('branch_id', $branchScope))
                ->pluck('id');

            $waitingAtBranch = Appointment::owned($owner)
                ->where('organization_id', $organization->id)
                ->where('branch_id', $branchId)
                ->whereIn('status', [Appointment::STATUS_WAITING, Appointment::STATUS_CHECKED_IN])
                ->when($departmentIds->isNotEmpty(), fn ($q) => $q->whereIn('department_id', $departmentIds))
                ->when($departmentIds->isEmpty(), fn ($q) => $q->whereRaw('1 = 0'))
                ->count();

            $waitingOrg = Appointment::owned($owner)
                ->where('organization_id', $organization->id)
                ->whereIn('status', [Appointment::STATUS_WAITING, Appointment::STATUS_CHECKED_IN])
                ->when($departmentIds->isNotEmpty(), fn ($q) => $q->whereIn('department_id', $departmentIds))
                ->when($departmentIds->isEmpty(), fn ($q) => $q->whereRaw('1 = 0'))
                ->count();

            $branchName = \App\Models\Branch::owned($owner)->whereKey($branchId)->value('name') ?: 'this branch';

            if ($waitingAtBranch > 0) {
                return back()->with(
                    'info',
                    "{$waitingAtBranch} patient(s) are waiting at {$branchName}, but none have a callable ticket at a service desk yet. Use Start on the queue, or check in again so a ticket is issued."
                );
            }

            if ($waitingOrg > $waitingAtBranch) {
                return back()->with(
                    'info',
                    "No patients waiting at {$branchName}. {$waitingOrg} are waiting at other branches — switch branch or open History."
                );
            }

            return back()->with('info', 'No patients waiting in this queue.');
        }

        $entity = $result['entity'] ?? null;
        if ($entity instanceof Appointment) {
            return $advance->redirectToOpenedPatient(
                $entity,
                $ticket,
                'care.queue.index',
            );
        }

        $name = $ticket['customer_name'] ?? 'patient';

        return back()->with('success', 'Called '.$ticket['ticket_number'].' — '.$name.'.');
    }

    /**
     * Refer a patient into this specialty queue (walk-in) without full clinical edit access.
     */
    public function refer(
        Request $request,
        string $module,
        SpecialtyModuleService $modules,
        AppointmentService $appointments,
    ): RedirectResponse {
        $definition = $modules->definition($module);
        abort_unless($definition, 404);

        $organization = $this->organization($request);
        $member = $this->member($request);
        abort_unless($modules->memberCanRefer($organization, $member, $module), 403);

        $owner = $this->ownerRef($request);
        $branchScope = app(OrganizationResolver::class)->branchScope($member);

        $validated = $request->validate([
            'patient_id' => ['required', 'integer', 'exists:care_patients,id'],
            'branch_id' => ['nullable', 'integer', 'exists:care_branches,id'],
            'reason' => ['nullable', 'string', 'max:500'],
            'notes' => ['nullable', 'string', 'max:2000'],
        ]);

        $branchId = (int) ($validated['branch_id'] ?? $branchScope ?? 0);
        abort_unless($branchId > 0, 422);
        $this->authorizeBranch($request, $branchId);

        $department = Department::owned($owner)
            ->where('type', $definition['department_type'] ?? 'general')
            ->where('branch_id', $branchId)
            ->where('is_active', true)
            ->orderBy('id')
            ->first();

        if (! $department) {
            return back()->with('error', 'No active '.($definition['label'] ?? $module).' department at this branch.');
        }

        $patient = \App\Models\Patient::owned($owner)
            ->where('organization_id', $organization->id)
            ->findOrFail((int) $validated['patient_id']);

        $appointment = $appointments->walkIn($organization, $owner, [
            'patient_id' => $patient->id,
            'branch_id' => $branchId,
            'department_id' => $department->id,
            'reason' => $validated['reason'] ?? ('Referral to '.($definition['label'] ?? $module)),
            'notes' => $validated['notes'] ?? null,
        ], $owner);

        \App\Services\Care\AuditLogger::record(
            $owner,
            'specialty.referral',
            $organization->id,
            $owner,
            Appointment::class,
            $appointment->id,
            ['module' => $module, 'department_id' => $department->id],
        );

        return redirect()
            ->route('care.queue.index')
            ->with('success', 'Referred '.$patient->fullName().' to '.($definition['label'] ?? $module).'.');
    }

    protected function renderShell(
        Request $request,
        string $module,
        string $section,
        SpecialtyModuleService $modules,
        SpecialtyShellService $shell,
        CareQueueBridge $queueBridge,
        ?Visit $visit = null,
    ): View {
        $definition = $modules->definition($module);
        abort_unless($definition, 404);

        $organization = $this->organization($request);
        $member = $this->member($request);
        abort_unless($modules->memberCanAccess($organization, $member, $module), 403);

        $canManageSpecialty = $modules->memberCanManage($organization, $member, $module);
        $canViewSpecialty = $modules->memberCanView($organization, $member, $module);
        $canReferSpecialty = $modules->memberCanRefer($organization, $member, $module);
        $specialtyAccessLevel = $modules->memberAccessLevel($organization, $member, $module);

        $owner = $this->ownerRef($request);
        $resolver = app(OrganizationResolver::class);
        $branchScope = $resolver->branchScope($member);
        $practitionerScope = $resolver->practitionerScope($organization, $member);

        $departments = Department::owned($owner)
            ->where('type', $definition['department_type'] ?? 'general')
            ->where('is_active', true)
            ->when($branchScope, fn ($q) => $q->where('branch_id', $branchScope))
            ->with('branch')
            ->orderBy('name')
            ->get();

        $departmentIds = $departments->pluck('id')->all();

        $branchId = (int) ($branchScope ?: $departments->first()?->branch_id);
        if ($practitionerScope !== null && $practitionerScope !== []) {
            $pracBranch = (int) \App\Models\Practitioner::owned($owner)
                ->whereKey($practitionerScope[0])
                ->value('branch_id');
            if ($pracBranch > 0) {
                $branchId = $pracBranch;
            }
        }

        // Match Call next: when the member has no branch scope (e.g. hospital admin),
        // KPIs / waiting lists use the same branch as queue ops so WAITING isn't org-wide
        // while Call next is local.
        $kpiBranch = $branchScope ?? ($branchId > 0 ? $branchId : null);

        $waiting = Appointment::owned($owner)
            ->where('organization_id', $organization->id)
            ->whereIn('status', [Appointment::STATUS_WAITING, Appointment::STATUS_CHECKED_IN])
            ->when($departmentIds !== [], fn ($q) => $q->whereIn('department_id', $departmentIds))
            ->when($departmentIds === [], fn ($q) => $q->whereRaw('1 = 0'))
            ->when($kpiBranch, fn ($q) => $q->where('branch_id', $kpiBranch))
            ->when(
                $practitionerScope !== null,
                fn ($q) => $q->whereIn('practitioner_id', $practitionerScope ?: [0]),
            )
            ->with(['patient', 'practitioner', 'department', 'visit'])
            ->orderBy('queue_position')
            ->orderBy('checked_in_at')
            ->limit(50)
            ->get();

        $inConsultation = Appointment::owned($owner)
            ->where('organization_id', $organization->id)
            ->where('status', Appointment::STATUS_IN_CONSULTATION)
            ->when($departmentIds !== [], fn ($q) => $q->whereIn('department_id', $departmentIds))
            ->when($departmentIds === [], fn ($q) => $q->whereRaw('1 = 0'))
            ->when($kpiBranch, fn ($q) => $q->where('branch_id', $kpiBranch))
            ->when(
                $practitionerScope !== null,
                fn ($q) => $q->whereIn('practitioner_id', $practitionerScope ?: [0]),
            )
            ->with(['patient', 'practitioner', 'consultation', 'visit'])
            ->orderBy('started_at')
            ->limit(50)
            ->get();

        $shellDefinition = $shell->definition($module);
        $kpis = $shell->kpis($organization, $module, $owner, $kpiBranch, $practitionerScope);
        $openVisits = $shell->openVisits($organization, $module, $owner, $kpiBranch, $practitionerScope);
        $visitHistory = $section === 'history'
            ? $shell->visitHistory($organization, $module, $owner, $kpiBranch, $practitionerScope)
            : collect();
        $services = $shell->provisionedServices($organization, $module);

        $permissions = app(\App\Services\Care\CarePermissions::class);
        // Ability-based for every role (doctor, nurse, receptionist, lab, pharmacist, …).
        // Module canManage alone is not enough — flags must match what mutate routes authorize.
        $canConsult = $permissions->can($member, 'consultations.manage') && $canManageSpecialty;
        $canAdvanceStage = $canConsult;
        $canStartConsultation = $canConsult;
        $canCallNext = $canManageSpecialty;
        $canManageClinical = $canManageSpecialty;
        $canManageVitals = $canManageSpecialty && (
            $permissions->can($member, 'vitals.manage')
            || $permissions->can($member, 'consultations.manage')
        );
        $canManageQueue = $permissions->can($member, 'appointments.manage') && $canManageSpecialty;
        $canBookAppointments = $permissions->can($member, 'appointments.manage');
        $canViewPatients = $permissions->can($member, 'patients.view');
        $canViewAppointments = $permissions->can($member, 'appointments.view');
        $branchLabel = $branchId
            ? (string) (\App\Models\Branch::owned($owner)->whereKey($branchId)->value('name') ?? '')
            : '';

        $workspaceVisit = null;
        $patientHeader = null;
        $timeline = [];
        $clinicalRecord = null;
        $clinicalFields = [];
        $clinicalAlerts = [];
        $visitDocuments = collect();
        $investigationTypes = collect();
        $dentalChart = null;
        $dentalTeethMap = [];
        $dentalPlan = null;
        $dentalPlanHistory = collect();
        $dentalProcedures = collect();
        $dentalImages = collect();
        $dentalVisitNote = null;
        $dentalCatalog = [];
        $dentalRows = [];
        $dentalConditions = [];
        $dentalStatuses = [];
        $dentalSurfaces = [];
        $dentalModalities = [];
        $dentalDentitions = [];
        $dentalPerioExam = null;
        $dentalPerioSurfaces = [];
        $dentalLabCases = collect();
        $dentalLabCaseTypes = [];
        $dentalLabCaseStatuses = [];
        $dentalRecalls = collect();
        $dentalStageCodes = [];
        $emergencyTriage = null;
        $emergencyClinicalNote = null;
        $emergencyObservation = null;
        $emergencyDisposition = null;
        $emergencyVitals = collect();
        $emergencyLatestVitals = null;
        $emergencyStageCodes = [];
        $emergencyStageFlow = [];
        $activeTab = (string) $request->query('tab', array_key_first($shell->workspaceTabs($module)) ?: 'overview');
        $clinical = app(SpecialtyClinicalRecordService::class);

        if ($visit) {
            abort_unless($visit->organization_id === $organization->id, 404);
            $visit->load([
                'patient.allergies',
                'patient.emergencyContacts',
                'patient.attachments',
                'appointment.practitioner',
                'appointment.consultation.investigationRequests.investigationType',
                'bill.lineItems',
                'consultations.investigationRequests.investigationType',
            ]);
            $workspaceVisit = $visit;
            if ($visit->patient) {
                $patientHeader = array_merge(
                    ['patient' => $visit->patient, 'visit' => $visit, 'appointment' => $visit->appointment],
                    $shell->patientHeaderMeta($visit->patient),
                );
                $timeline = $shell->patientTimeline($visit->patient);
            }
        } elseif ($section === 'workspace') {
            $first = $openVisits->first();
            if ($first?->patient) {
                $first->load([
                    'patient.allergies',
                    'patient.emergencyContacts',
                    'patient.attachments',
                    'appointment.practitioner',
                    'appointment.consultation.investigationRequests.investigationType',
                    'bill.lineItems',
                    'consultations.investigationRequests.investigationType',
                ]);
                $workspaceVisit = $first;
                $patientHeader = array_merge(
                    ['patient' => $first->patient, 'visit' => $first, 'appointment' => $first->appointment],
                    $shell->patientHeaderMeta($first->patient),
                );
                $timeline = $shell->patientTimeline($first->patient);
            }
        }

        if ($workspaceVisit && $section === 'workspace') {
            $recordType = $clinical->recordTypeForTab($module, $activeTab);
            if ($recordType) {
                $clinicalRecord = $clinical->findForVisit($workspaceVisit, $module, $recordType);
                $clinicalFields = $clinical->fieldsFor($module, $recordType);
            }
            $clinicalAlerts = $clinical->alertsForVisit($workspaceVisit, $module);

            if ($module === 'dentistry' && $workspaceVisit->patient) {
                $chartService = app(\App\Services\Care\Dentistry\DentalChartService::class);
                $planService = app(\App\Services\Care\Dentistry\DentalTreatmentPlanService::class);
                $analytics = app(\App\Services\Care\Dentistry\DentalAnalyticsService::class);
                $perioService = app(\App\Services\Care\Dentistry\DentalPerioService::class);
                $labService = app(\App\Services\Care\Dentistry\DentalLabCaseService::class);
                $recallService = app(\App\Services\Care\Dentistry\DentalRecallService::class);

                $dentalChart = $chartService->chartForPatient($organization, $workspaceVisit->patient, $owner);
                $dentalTeethMap = $chartService->teethMap($dentalChart);
                $dentalPlan = $planService->activePlanForPatient($organization, $workspaceVisit->patient, $owner);
                $dentalPlanHistory = $planService->plansForPatient($organization, $workspaceVisit->patient, $owner);
                $dentalProcedures = \App\Models\DentalProcedure::owned($owner)
                    ->where('visit_id', $workspaceVisit->id)
                    ->orderByDesc('id')
                    ->get();
                $dentalImages = \App\Models\DentalImage::owned($owner)
                    ->where(function ($q) use ($workspaceVisit) {
                        $q->where('visit_id', $workspaceVisit->id)
                            ->orWhere(function ($q2) use ($workspaceVisit) {
                                $q2->where('patient_id', $workspaceVisit->patient_id)
                                    ->whereNull('visit_id');
                            });
                    })
                    ->with('attachment')
                    ->orderByDesc('id')
                    ->limit(40)
                    ->get();
                $dentalVisitNote = \App\Models\DentalVisitNote::owned($owner)
                    ->where('visit_id', $workspaceVisit->id)
                    ->first();
                $dentalCatalog = $shell->provisionedServices($organization, 'dentistry');
                $dentition = $dentalChart->dentition ?: \App\Services\Care\Dentistry\DentalCatalog::DENTITION_ADULT;
                $dentalRows = \App\Services\Care\Dentistry\DentalCatalog::odontogramRows($dentition);
                $dentalConditions = \App\Services\Care\Dentistry\DentalCatalog::conditions();
                $dentalStatuses = \App\Services\Care\Dentistry\DentalCatalog::toothStatuses();
                $dentalSurfaces = \App\Services\Care\Dentistry\DentalCatalog::surfaces();
                $dentalModalities = \App\Services\Care\Dentistry\DentalCatalog::modalities();
                $dentalDentitions = \App\Services\Care\Dentistry\DentalCatalog::dentitions();
                $dentalPerioExam = $perioService->latestForPatient($organization, $workspaceVisit->patient, $owner);
                $dentalPerioSurfaces = \App\Services\Care\Dentistry\DentalCatalog::perioSurfaces();
                $dentalLabCases = $labService->casesForPatient($organization, $workspaceVisit->patient, $owner);
                $dentalLabCaseTypes = \App\Services\Care\Dentistry\DentalCatalog::labCaseTypes();
                $dentalLabCaseStatuses = \App\Services\Care\Dentistry\DentalCatalog::labCaseStatuses();
                $dentalRecalls = $recallService->recallsForPatient($organization, $workspaceVisit->patient, $owner);
                $dentalStageCodes = collect($shell->stages('dentistry'))->pluck('code')->all();

                $clinicalAlerts = array_merge(
                    $clinicalAlerts,
                    $analytics->alertsForPatient($organization, $workspaceVisit->patient, $owner),
                );
            }

            if ($module === 'emergency') {
                $emergencyTriage = $clinical->findForVisit($workspaceVisit, 'emergency', 'triage');
                $emergencyClinicalNote = $clinical->findForVisit($workspaceVisit, 'emergency', 'clinical_note');
                $emergencyObservation = $clinical->findForVisit($workspaceVisit, 'emergency', 'observation');
                $emergencyDisposition = $clinical->findForVisit($workspaceVisit, 'emergency', 'disposition');
                $vitalsService = app(\App\Services\Care\Emergency\EmergencyVitalsService::class);
                $emergencyVitals = $vitalsService->forVisit($workspaceVisit);
                $emergencyLatestVitals = $vitalsService->latestForVisit($workspaceVisit);
                $emergencyStageCodes = collect($shell->stages('emergency'))->pluck('code')->all();
                $emergencyStageFlow = app(\App\Services\Care\Emergency\EmergencyWorkflowService::class)->stageFlow();
            }

            if ($patientHeader !== null) {
                $patientHeader['clinical_alerts'] = $clinicalAlerts;
            }
            $visitDocuments = $workspaceVisit->patient
                ? $workspaceVisit->patient->attachments()
                    ->where(function ($q) use ($module) {
                        $q->where('document_type', 'specialty_'.$module)
                            ->orWhere('document_type', 'other')
                            ->orWhereNull('document_type');
                    })
                    ->orderByDesc('id')
                    ->limit(20)
                    ->get()
                : collect();

            if ($activeTab === 'orders' && $canConsult) {
                $investigationTypes = InvestigationType::query()
                    ->where('organization_id', $organization->id)
                    ->where('is_active', true)
                    ->orderBy('name')
                    ->get();
            }
        }

        return view('care.specialty.shell', [
            'organization' => $organization,
            'moduleKey' => $module,
            'definition' => $shellDefinition,
            'section' => $section,
            'navItems' => $shell->navItems($module),
            'waiting' => $waiting,
            'queue' => $waiting,
            'inConsultation' => $inConsultation,
            'openVisits' => $openVisits,
            'visitHistory' => $visitHistory,
            'kpis' => $kpis,
            'stages' => $shell->stages($module),
            'services' => $services,
            'workspaceTabs' => $shell->workspaceTabs($module),
            'actions' => $shell->actions($module),
            'activeTab' => $activeTab,
            'workspaceVisit' => $workspaceVisit,
            'patientHeader' => $patientHeader,
            'timeline' => $timeline,
            'clinicalRecord' => $clinicalRecord,
            'clinicalFields' => $clinicalFields,
            'clinicalAlerts' => $clinicalAlerts,
            'visitDocuments' => $visitDocuments,
            'investigationTypes' => $investigationTypes,
            'dentalChart' => $dentalChart,
            'dentalTeethMap' => $dentalTeethMap,
            'dentalPlan' => $dentalPlan,
            'dentalPlanHistory' => $dentalPlanHistory,
            'dentalProcedures' => $dentalProcedures,
            'dentalImages' => $dentalImages,
            'dentalVisitNote' => $dentalVisitNote,
            'dentalCatalog' => $dentalCatalog,
            'dentalRows' => $dentalRows,
            'dentalConditions' => $dentalConditions,
            'dentalStatuses' => $dentalStatuses,
            'dentalSurfaces' => $dentalSurfaces,
            'dentalModalities' => $dentalModalities,
            'dentalDentitions' => $dentalDentitions,
            'dentalPerioExam' => $dentalPerioExam,
            'dentalPerioSurfaces' => $dentalPerioSurfaces,
            'dentalLabCases' => $dentalLabCases,
            'dentalLabCaseTypes' => $dentalLabCaseTypes,
            'dentalLabCaseStatuses' => $dentalLabCaseStatuses,
            'dentalRecalls' => $dentalRecalls,
            'dentalStageCodes' => $dentalStageCodes,
            'emergencyTriage' => $emergencyTriage,
            'emergencyClinicalNote' => $emergencyClinicalNote,
            'emergencyObservation' => $emergencyObservation,
            'emergencyDisposition' => $emergencyDisposition,
            'emergencyVitals' => $emergencyVitals,
            'emergencyLatestVitals' => $emergencyLatestVitals,
            'emergencyStageCodes' => $emergencyStageCodes,
            'emergencyStageFlow' => $emergencyStageFlow,
            'queueStubs' => $modules->queueStubsFor($organization, $module),
            'branchId' => $branchId,
            'branchLabel' => $branchLabel,
            'practitionerScope' => $practitionerScope,
            'lockToPractitioner' => $practitionerScope !== null,
            'canConsult' => $canConsult,
            'canAdvanceStage' => $canAdvanceStage,
            'canStartConsultation' => $canStartConsultation,
            'canCallNext' => $canCallNext,
            'canManageClinical' => $canManageClinical,
            'canManageVitals' => $canManageVitals,
            'canManageQueue' => $canManageQueue,
            'canBookAppointments' => $canBookAppointments,
            'canViewPatients' => $canViewPatients,
            'canViewAppointments' => $canViewAppointments,
            'canManageSpecialty' => $canManageSpecialty,
            'canViewSpecialty' => $canViewSpecialty,
            'canReferSpecialty' => $canReferSpecialty,
            'specialtyAccessLevel' => $specialtyAccessLevel,
            'queueIntegration' => $branchId
                ? $queueBridge->listMeta($organization, $module, $branchId)
                : ['enabled' => false],
            'currency' => strtoupper((string) config('care.billing.currency', config('care.currency', 'GHS'))),
        ]);
    }
}