fix: reconcile assigned family insurance rate on updated participant

src/Form/Model/BookingDto.php

@@ -70,6 +70,21 @@ class BookingDto
      */
     public ?string $originalFingerprint = null;
 
+    /**
+     * Whether the applicant has already been notified that family insurance became
+     * available after they picked a non-family insurance while dependents were incomplete.
+     * Prevents re-showing the same hint on every subsequent participant card submission.
+     */
+    public bool $familyInsuranceHintShown = false;
+
+    /**
+     * Whether the applicant's current insurance choice was made while family insurance
+     * was not yet eligible (i.e. before all dependents' dates of birth were known).
+     * Set at selection time; used to distinguish "family insurance just became
+     * available" from "it was available all along and the applicant chose otherwise".
+     */
+    public bool $applicantInsuranceChosenWhileFamilyIneligible = false;
+
     public function __construct(public Travel $travel, public int $hotelId)
     {
     }

src/Form/Model/ParticipantEditDto.php

@@ -67,9 +67,9 @@ class ParticipantEditDto
      * Validates that insurance is selected when required.
      *
      * Insurance is required for all participants in create mode, EXCEPT for dependent
-     * participants when the applicant has enabled bulk insurance booking. In that case,
-     * the insurance field is hidden and will be automatically assigned by the bulk
-     * insurance handler.
+     * participants when the applicant has enabled bulk insurance booking, or when the
+     * applicant has a family insurance selected. In both cases, the insurance field is
+     * hidden and coverage is derived from the applicant instead.
      *
      * In edit submissions, this validation is skipped entirely because insurance
      * data is readonly and preserved as-is from the BPN API.
@@ -90,6 +90,10 @@ class ParticipantEditDto
             if (true === $applicant?->bulkInsuranceBooking) {
                 return;
             }
+
+            if (null !== $applicant?->insurance && true === $applicant->insurance->familyInsurance) {
+                return;
+            }
         }
 
         if (null === $this->participant->insurance) {

src/Form/Service/ParticipantInsuranceFieldHandler.php

@@ -6,6 +6,7 @@ namespace App\Form\Service;
 
 use App\BusProNet\Model\Insurance;
 use App\Form\Model\BookingDto;
+use App\Form\Model\ParticipantDto;
 use App\Form\Service\Abstract\AbstractParticipantFieldHandler;
 use App\Service\BookingPriceCalculator;
 use App\Service\InsuranceManager;
@@ -124,6 +125,19 @@ class ParticipantInsuranceFieldHandler extends AbstractParticipantFieldHandler
      * @param int                  $participantIndex The index of the participant being processed
      */
     public function processField(array $submittedData, BookingDto $bookingDto, int $participantIndex): void
+    {
+        $this->applyInsuranceSelection($submittedData, $bookingDto, $participantIndex);
+
+        // Runs after the selection above is fully resolved, so a submission that itself
+        // switches the applicant to family insurance doesn't trigger a stale "please
+        // recheck" notification about the choice it just made.
+        $this->notifyApplicantIfFamilyInsuranceNewlyAvailable($bookingDto);
+    }
+
+    /**
+     * @param array<string, mixed> $submittedData The submitted participant form data
+     */
+    private function applyInsuranceSelection(array $submittedData, BookingDto $bookingDto, int $participantIndex): void
     {
         $participant = $bookingDto->getParticipant($participantIndex);
         if (null === $participant) {
@@ -152,6 +166,8 @@ class ParticipantInsuranceFieldHandler extends AbstractParticipantFieldHandler
                 $noInsurance->price = 0.0;
                 $participant->insurance = $noInsurance;
 
+                $this->recordFamilyIneligibilityAtSelectionTime($bookingDto, $participantIndex, $noInsurance);
+
                 return; // Skip all other processing for "no insurance"
             }
 
@@ -188,10 +204,15 @@ class ParticipantInsuranceFieldHandler extends AbstractParticipantFieldHandler
                 // Insurance not found - clear selection
                 $participant->insurance = null;
             }
+
+            $this->recordFamilyIneligibilityAtSelectionTime($bookingDto, $participantIndex, $participant->insurance);
         }
 
         // Handle form resubmission with existing insurance (automatic reassignment check)
-        if (null !== $currentInsurance && null !== $selectedInsuranceId) {
+        // Only applies when the selection didn't just change above - otherwise this would
+        // re-validate the now-stale $currentInsurance and could overwrite the fresh selection
+        // the block above already made in this same request.
+        if (!$isNewSelection && null !== $currentInsurance && null !== $selectedInsuranceId) {
             // Preserve "no insurance" selection during resubmission
             if ($currentInsurance->isNoInsurance()) {
                 return;
@@ -260,6 +281,95 @@ class ParticipantInsuranceFieldHandler extends AbstractParticipantFieldHandler
         return [];
     }
 
+    /**
+     * Records whether the applicant's insurance choice was made while family insurance
+     * was NOT yet eligible, so the notification below can tell "just became available"
+     * apart from "was available all along and the applicant chose non-family anyway".
+     *
+     * Only called when the applicant (index 0) makes a genuine new selection - not on
+     * mere resubmission/price-tier reassignment of an already-standing choice.
+     */
+    private function recordFamilyIneligibilityAtSelectionTime(BookingDto $bookingDto, int $participantIndex, ?Insurance $insurance): void
+    {
+        if (0 !== $participantIndex || null === $insurance || true === $insurance->familyInsurance) {
+            return;
+        }
+
+        $applicant = $bookingDto->getParticipant(0);
+        if (null === $applicant) {
+            return;
+        }
+
+        $bookingDto->applicantInsuranceChosenWhileFamilyIneligible = !$this->hasEligibleFamilyInsurance($bookingDto, $applicant);
+    }
+
+    /**
+     * Checks whether a family insurance is actually eligible right now - not just whether
+     * the participant composition qualifies as a family booking, but whether a selectable
+     * family insurance product actually matches the current total booking price.
+     *
+     * Used by both the selection-time recording above and the notification below, so they
+     * can never disagree on what "family insurance is eligible" means.
+     */
+    private function hasEligibleFamilyInsurance(BookingDto $bookingDto, ParticipantDto $applicant): bool
+    {
+        if (!$bookingDto->isFamilyBooking()) {
+            return false;
+        }
+
+        $selectableInsurances = $this->insuranceService->getSelectableInsurances($bookingDto->travel);
+        $familyInsurances = array_values(array_filter($selectableInsurances, static fn (Insurance $i) => true === $i->familyInsurance));
+
+        if ([] === $familyInsurances) {
+            return false;
+        }
+
+        $totalPrice = $this->priceCalculatorService->calculateTotalBookingPriceExcludingInsurance($bookingDto);
+
+        return [] !== $this->insuranceService->getEligibleInsurances($familyInsurances, $applicant, $bookingDto, $totalPrice);
+    }
+
+    /**
+     * Notifies the applicant when family insurance becomes available after the fact.
+     *
+     * Participants are entered one card at a time, in any order, so the applicant is
+     * likely to pick a non-family insurance before any dependent's date of birth makes
+     * the booking eligible for family insurance. Once that happens, nothing prompts the
+     * applicant to revisit their earlier choice. This surfaces a one-time hint via the
+     * existing notification/toast pipeline (App\Form\Model\ParticipantDto::addNotification()),
+     * mirroring the cross-participant side effect already used by
+     * ParticipantAssignedRoomFieldHandler::resolveRoomCapacityConflict() for room conflicts.
+     *
+     * Requires `applicantInsuranceChosenWhileFamilyIneligible` to be true - i.e. the
+     * choice was actually made before family insurance was possible - not just that
+     * family insurance happens to be eligible now (it may have been all along).
+     */
+    private function notifyApplicantIfFamilyInsuranceNewlyAvailable(BookingDto $bookingDto): void
+    {
+        if ($bookingDto->familyInsuranceHintShown) {
+            return;
+        }
+
+        if (!$bookingDto->applicantInsuranceChosenWhileFamilyIneligible) {
+            return;
+        }
+
+        $applicant = $bookingDto->getParticipant(0);
+        if (null === $applicant || null === $applicant->insurance || true === $applicant->insurance->familyInsurance) {
+            return;
+        }
+
+        if (!$this->hasEligibleFamilyInsurance($bookingDto, $applicant)) {
+            return;
+        }
+
+        $applicant->addNotification(
+            'info',
+            'Für eure Konstellation ist auch eine Familienversicherung verfügbar und kann über die anmeldende Person gebucht werden.'
+        );
+        $bookingDto->familyInsuranceHintShown = true;
+    }
+
     /**
      * Finds an insurance by ID from the available insurances array.
      *