<?php
/**
 * Reschedule an existing booking onto a new slot.
 *
 * @package Bookline
 */

declare( strict_types=1 );

namespace Bookline\Application\Booking;

use Bookline\Application\Bus;
use Bookline\Domain\Booking\Booking;
use Bookline\Domain\Booking\BookingPolicy;
use Bookline\Domain\Booking\BookingRepository;
use Bookline\Domain\Booking\Events\BookingRescheduled;
use Bookline\Domain\Booking\SlotConflictChecker;
use Bookline\Domain\Booking\SlotTakenException;
use Bookline\Domain\Service\ServiceRepository;
use Bookline\Domain\Shared\Clock;
use Bookline\Domain\Shared\DomainException;
use Bookline\Domain\Shared\TimeZoneId;
use Bookline\Infrastructure\Persistence\TransactionManager;
use DateTimeImmutable;

/**
 * Reschedule with excludeBookingId so the booking may land on its own slot.
 *
 * @since 0.1.0
 */
final class RescheduleBookingHandler {

	/**
	 * Constructor.
	 *
	 * @param BookingRepository   $bookings  Booking port.
	 * @param ServiceRepository   $services  Service port.
	 * @param TransactionManager  $tx        Transactions.
	 * @param Bus                 $bus       Event bus.
	 * @param Clock               $clock     Clock.
	 * @param BookingPolicy       $policy    Policy windows.
	 * @param ReminderCanceller   $reminders Reminder stub.
	 * @param SlotConflictChecker $conflicts Capacity checker.
	 */
	public function __construct(
		private readonly BookingRepository $bookings,
		private readonly ServiceRepository $services,
		private readonly TransactionManager $tx,
		private readonly Bus $bus,
		private readonly Clock $clock,
		private readonly BookingPolicy $policy,
		private readonly ReminderCanceller $reminders,
		private readonly SlotConflictChecker $conflicts = new SlotConflictChecker(),
	) {}

	/**
	 * Reschedule in place.
	 *
	 * @param int               $booking_id       Booking id.
	 * @param DateTimeImmutable $start_utc        New start.
	 * @param DateTimeImmutable $end_utc          New end.
	 * @param DateTimeImmutable $buffer_start_utc New buffer start.
	 * @param DateTimeImmutable $buffer_end_utc   New buffer end.
	 * @param DateTimeImmutable $start_local      New local start.
	 * @param TimeZoneId|null   $timezone          Optional zone override.
	 *
	 * @throws DomainException When policy fails or the slot is taken (SlotTakenException).
	 *
	 * @since 0.1.0
	 */
	public function handle(
		int $booking_id,
		DateTimeImmutable $start_utc,
		DateTimeImmutable $end_utc,
		DateTimeImmutable $buffer_start_utc,
		DateTimeImmutable $buffer_end_utc,
		DateTimeImmutable $start_local,
		?TimeZoneId $timezone = null,
	): Booking {
		$now     = $this->clock->now();
		$booking = $this->bookings->find_by_id( $booking_id );
		if ( null === $booking ) {
			throw new DomainException( 'booking.not_found', 'Booking not found.' );
		}

		$policy = $this->policy->assert_reschedulable( $booking, $now );
		if ( $policy->is_err() ) {
			throw new DomainException( esc_html( $policy->error_code() ), esc_html( $policy->error_message() ) );
		}

		$service = $this->services->find_by_id( $booking->service_id() );
		if ( null === $service ) {
			throw new DomainException( 'booking.service_missing', 'Service not found.' );
		}

		$agent_id = $booking->agent_id();
		if ( null === $agent_id ) {
			throw new DomainException( 'booking.agent_required', 'Agent is required.' );
		}

		$previous_start = $booking->start_utc();
		$unique_lock    = 1 === $service->capacity_max();
		$zone           = $timezone ?? $booking->timezone();

		$updated = $this->tx->run(
			function () use (
				$booking,
				$service,
				$agent_id,
				$start_utc,
				$end_utc,
				$buffer_start_utc,
				$buffer_end_utc,
				$start_local,
				$zone,
				$unique_lock,
				$now
			): Booking {
				$this->bookings->lock_agent_for_update( $agent_id );
				$overlapping = $this->bookings->lock_overlapping_for_agent(
					$agent_id,
					$buffer_start_utc,
					$buffer_end_utc,
					$booking->id()
				);

				if ( $this->conflicts->is_taken(
					$overlapping,
					$start_utc,
					$booking->service_id(),
					$booking->attendees(),
					$service->capacity_max(),
					$booking->id()
				) ) {
					throw new SlotTakenException();
				}

				$booking->reschedule_in_place(
					$start_utc,
					$end_utc,
					$buffer_start_utc,
					$buffer_end_utc,
					$start_local,
					$zone,
					$now
				);
				$this->bookings->save( $booking, $unique_lock );
				return $booking;
			}
		);

		$this->reminders->cancel_for_booking( (int) $updated->id() );
		$this->bus->dispatch(
			new BookingRescheduled(
				(int) $updated->id(),
				$updated->uuid(),
				$previous_start,
				$updated->start_utc(),
				$now
			)
		);

		return $updated;
	}
}