<?php

declare(strict_types=1);

namespace App\Service;

use App\BusProNet\Model\Insurance;
use App\BusProNet\Traits\SortByPriceTrait;
use App\Form\Model\BookingDto;
use App\Form\Model\ParticipantDto;
use App\Model\InsuranceEligibilityCriteria;
use Carbon\Carbon;

/**
 * Service for matching insurances to participants based on eligibility criteria.
 *
 * Evaluates insurance constraints including age limits, travel dates, booking windows,
 * travel price ranges, and duration limits to determine which insurances are available
 * for specific participants and booking scenarios.
 */
class InsuranceMatchingService
{
    use SortByPriceTrait;

    public function __construct(
        private readonly BookingPriceCalculatorService $priceCalculatorService,
    ) {
    }

    /**
     * Filters insurances based on participant and booking criteria.
     *
     * @param array<Insurance> $insurances  Available insurances to filter
     * @param ParticipantDto   $participant The participant to match insurances for
     * @param BookingDto       $booking     The booking context for additional criteria
     *
     * @return array<Insurance> Filtered array of eligible insurances
     */
    public function getEligibleInsurances(array $insurances, ParticipantDto $participant, BookingDto $booking): array
    {
        $criteria = $this->createEligibilityCriteria($participant, $booking);

        if (null === $criteria) {
            return []; // Cannot match insurances without travel dates
        }

        $eligibleInsurances = array_filter(
            $insurances,
            fn (Insurance $insurance) => $this->isInsuranceEligible($insurance, $criteria)
        );

        return $this->sortByPrice($eligibleInsurances);
    }

    /**
     * Auto-reassigns an insurance to the same type with appropriate price tier.
     *
     * This method is used when a participant's individual price changes and their
     * current insurance is no longer eligible. It finds the same insurance type
     * (subType + familyInsurance) with the correct price tier.
     *
     * @param array<Insurance> $availableInsurances All available insurances
     * @param Insurance        $currentInsurance    The currently selected insurance
     * @param ParticipantDto   $participant         The participant to reassign for
     * @param BookingDto       $booking             The booking context
     *
     * @return Insurance|null The reassigned insurance or null if no suitable match found
     */
    public function reassignInsuranceForPriceChange(array $availableInsurances, Insurance $currentInsurance, ParticipantDto $participant, BookingDto $booking): ?Insurance
    {
        // Group insurances of the same type
        $sameTypeInsurances = $this->filterInsurancesByType($availableInsurances, $currentInsurance);

        // Get eligible insurances for this participant
        $eligibleInsurances = $this->getEligibleInsurances($sameTypeInsurances, $participant, $booking);

        // Return the first eligible insurance (they should all be equivalent for the same type)
        return !empty($eligibleInsurances) ? array_values($eligibleInsurances)[0] : null;
    }

    /**
     * Batch-assigns insurances of the same type to all participants based on individual pricing.
     *
     * FUTURE FEATURE: This method will be used when implementing the "applicant assigns
     * insurance to all participants" feature. The applicant's selection will be propagated
     * to all participants with automatic price tier adjustment based on individual prices.
     *
     * This method takes the applicant's insurance selection and assigns the same insurance type
     * (subType + familyInsurance) to all participants, but selects the appropriate price tier
     * based on each participant's individual travel price.
     *
     * @param array<Insurance> $availableInsurances All available insurances
     * @param Insurance        $selectedInsurance   The insurance selected by the applicant
     * @param BookingDto       $booking             The booking with all participants
     *
     * @return array<int, Insurance|null> Array indexed by participant index with assigned insurances
     *
     * @internal Reserved for future feature implementation
     */
    public function batchAssignInsuranceToParticipants(array $availableInsurances, Insurance $selectedInsurance, BookingDto $booking): array
    {
        $assignments = [];

        // Group insurances of the same type
        $sameTypeInsurances = $this->filterInsurancesByType($availableInsurances, $selectedInsurance);

        // Assign appropriate insurance to each participant
        foreach ($booking->getParticipants() as $index => $participant) {
            $eligibleInsurances = $this->getEligibleInsurances($sameTypeInsurances, $participant, $booking);
            $assignments[$index] = !empty($eligibleInsurances) ? array_values($eligibleInsurances)[0] : null;
        }

        return $assignments;
    }

    /**
     * Creates eligibility criteria from participant and booking data.
     *
     * This method performs early validation before creating the criteria object
     * to avoid unnecessary object instantiation when criteria cannot be satisfied.
     */
    private function createEligibilityCriteria(ParticipantDto $participant, BookingDto $booking): ?InsuranceEligibilityCriteria
    {
        // Early return if travel dates are missing - cannot evaluate any criteria
        $travelStartDate = $booking->travel->dateFrom;
        $travelEndDate = $booking->travel->dateTo;

        if (null === $travelStartDate || null === $travelEndDate) {
            return null; // Cannot create criteria without travel dates
        }

        return new InsuranceEligibilityCriteria(
            participant: $participant,
            travelStartDate: $travelStartDate,
            travelEndDate: $travelEndDate,
            bookingDate: Carbon::now()->toDateTimeImmutable(),
            travelPrice: $this->calculateTravelPrice($booking, $participant->index),
            travelDurationDays: $this->calculateTravelDurationDays($travelStartDate, $travelEndDate),
            booking: $booking,
        );
    }

    /**
     * Checks if a specific insurance is eligible for given criteria.
     */
    private function isInsuranceEligible(Insurance $insurance, InsuranceEligibilityCriteria $criteria): bool
    {
        // Family insurance constraints
        if (false === $this->checkFamilyInsuranceConstraints($insurance, $criteria->booking)) {
            return false;
        }

        // Age constraints
        if (false === $this->checkAgeConstraints($insurance, $criteria->participant, $criteria->travelStartDate)) {
            return false;
        }

        // Travel date constraints
        if (false === $this->checkTravelDateConstraints($insurance, $criteria->travelStartDate, $criteria->travelEndDate)) {
            return false;
        }

        // Booking date constraints
        if (false === $this->checkBookingDateConstraints($insurance, $criteria->bookingDate)) {
            return false;
        }

        // Travel price constraints
        if (false === $this->checkTravelPriceConstraints($insurance, $criteria->travelPrice)) {
            return false;
        }

        // Travel duration constraints
        if (false === $this->checkTravelDurationConstraints($insurance, $criteria->travelDurationDays)) {
            return false;
        }

        return true;
    }

    /**
     * Checks if family insurance constraints are met.
     *
     * Family insurances should only be available for family bookings,
     * and individual insurances should only be available for non-family bookings.
     */
    private function checkFamilyInsuranceConstraints(Insurance $insurance, BookingDto $booking): bool
    {
        // Family booking detection only available in create mode
        if (BookingDto::MODE_EDIT === $booking->getMode()) {
            return true; // Skip family constraints for edit mode
        }

        $isFamilyBooking = $booking->isFamilyBooking();

        // If it's a family insurance, it should only be available for family bookings
        if (true === $insurance->familyInsurance && false === $isFamilyBooking) {
            return false;
        }

        // If it's not a family insurance, it should only be available for non-family bookings
        if (false === $insurance->familyInsurance && true === $isFamilyBooking) {
            return false;
        }

        return true;
    }

    /**
     * Checks if participant age meets insurance age constraints.
     */
    private function checkAgeConstraints(Insurance $insurance, ParticipantDto $participant, \DateTimeImmutable $travelStartDate): bool
    {
        $participantAge = $participant->getAge($travelStartDate);

        // If no birth date is provided, skip age constraints (field will be hidden via field state conditions)
        if (null === $participantAge) {
            return true;
        }

        // Check minimum age
        if (null !== $insurance->ageFrom && $participantAge < $insurance->ageFrom) {
            return false;
        }

        // Check maximum age
        if (null !== $insurance->ageTo && $participantAge > $insurance->ageTo) {
            return false;
        }

        return true;
    }

    /**
     * Checks if travel dates fall within insurance validity period.
     */
    private function checkTravelDateConstraints(Insurance $insurance, \DateTimeImmutable $travelStartDate, \DateTimeImmutable $travelEndDate): bool
    {
        // Check travel start date
        if (null !== $insurance->travelDateFrom && $travelStartDate < $insurance->travelDateFrom) {
            return false;
        }

        if (null !== $insurance->travelDateTo && $travelStartDate > $insurance->travelDateTo) {
            return false;
        }

        // Check travel end date
        if (null !== $insurance->travelDateTo && $travelEndDate > $insurance->travelDateTo) {
            return false;
        }

        return true;
    }

    /**
     * Checks if booking date falls within insurance booking window.
     */
    private function checkBookingDateConstraints(Insurance $insurance, \DateTimeImmutable $bookingDate): bool
    {
        // Check booking window start
        if (null !== $insurance->bookingDateFrom && $bookingDate < $insurance->bookingDateFrom) {
            return false;
        }

        // Check booking window end
        if (null !== $insurance->bookingDateTo && $bookingDate > $insurance->bookingDateTo) {
            return false;
        }

        return true;
    }

    /**
     * Checks if travel price falls within insurance price range.
     */
    private function checkTravelPriceConstraints(Insurance $insurance, float $travelPrice): bool
    {
        // Check minimum price
        if (null !== $insurance->travelPriceFrom && $travelPrice < $insurance->travelPriceFrom) {
            return false;
        }

        // Check maximum price
        if (null !== $insurance->travelPriceTo && $travelPrice > $insurance->travelPriceTo) {
            return false;
        }

        return true;
    }

    /**
     * Checks if travel duration falls within insurance duration limits.
     */
    private function checkTravelDurationConstraints(Insurance $insurance, int $travelDurationDays): bool
    {
        // Check minimum duration
        if (null !== $insurance->travelDurationFrom && $travelDurationDays < $insurance->travelDurationFrom) {
            return false;
        }

        // Check maximum duration
        if (null !== $insurance->travelDurationTo && $travelDurationDays > $insurance->travelDurationTo) {
            return false;
        }

        return true;
    }

    /**
     * Calculates the total travel price for a participant, excluding insurance prices.
     *
     * This method calculates the travel price used for insurance eligibility filtering.
     * It excludes insurance prices to prevent circular dependency where insurance selection
     * affects travel price which then affects insurance eligibility.
     *
     * @param BookingDto $booking          The booking to calculate price for
     * @param int        $participantIndex The participant index to calculate for
     *
     * @return float The total travel price for the participant excluding insurance
     */
    private function calculateTravelPrice(BookingDto $booking, int $participantIndex): float
    {
        // Use the price calculator to get the participant's individual price excluding insurance
        return $this->priceCalculatorService->calculateIndividualParticipantPriceExcludingInsurance($booking, $participantIndex);
    }

    /**
     * Calculates travel duration in days.
     *
     * @param \DateTimeImmutable $startDate Travel start date
     * @param \DateTimeImmutable $endDate   Travel end date
     *
     * @return int Duration in days
     */
    private function calculateTravelDurationDays(\DateTimeImmutable $startDate, \DateTimeImmutable $endDate): int
    {
        return $startDate->diff($endDate)->days;
    }

    /**
     * Filters insurances by type based on label (for packages) or subType (for individual insurances).
     *
     * This method groups insurances of the same type together for reassignment or batch assignment.
     * Insurance type matching strategy:
     * - **Packages**: Match by label + familyInsurance (packages with same label are different price tiers)
     * - **Individual insurances**: Match by subType + familyInsurance
     *
     * Example: "Reise-Rücktritt + Selbstbehaltübernahme" at €10, €14, €26 are the same type,
     * but different from "Reiseschutz Platin Auto/Bahn/Bus (Europa) + Selbstbehaltübernahme".
     *
     * @param array<Insurance> $insurances         All available insurances to filter
     * @param Insurance        $referenceInsurance The insurance to match against
     *
     * @return array<Insurance> Filtered insurances of the same type
     */
    private function filterInsurancesByType(array $insurances, Insurance $referenceInsurance): array
    {
        // For packages, match by label (packages with same label are different price tiers of same type)
        if (true === $referenceInsurance->package) {
            return array_filter(
                $insurances,
                fn (Insurance $insurance) => true === $insurance->package
                    && $insurance->label === $referenceInsurance->label
                    && $insurance->familyInsurance === $referenceInsurance->familyInsurance
            );
        }

        // For individual insurances, match by subType
        return array_filter(
            $insurances,
            fn (Insurance $insurance) => false === $insurance->package
                && $insurance->subType === $referenceInsurance->subType
                && $insurance->familyInsurance === $referenceInsurance->familyInsurance
        );
    }
}