Crussell/backend/handlers/bookings/overlap_test.go

//go:build test && dev
// +build test,dev

package bookings

import (
	"context"
	"encoding/json"
	"net/http"
	"strings"
	"testing"
	"time"

	"crussell/db"
	"crussell/mw"
	"crussell/testutils"
	"crussell/testutils/fixtures"
	"crussell/testutils/jwt"
)

// ============================================================================
// Helpers
// ============================================================================

// weekdayTime returns a far-future time on the given weekday at hour:00 UTC.
// Ensures at least 2 weeks out so all time-window checks (deposits, advance)
// pass without interference.
func weekdayTime(weekday time.Weekday, hour int) time.Time {
	now := time.Now().UTC()
	daysAhead := int(weekday) - int(now.Weekday())
	if daysAhead <= 0 {
		daysAhead += 7
	}
	// Push far enough forward that advance-window / deposit checks don't interfere
	daysAhead += 21
	result := now.AddDate(0, 0, daysAhead)
	return time.Date(result.Year(), result.Month(), result.Day(), hour, 0, 0, 0, time.UTC)
}

// durationMinutes returns the duration_minutes for a given service ID from the tx.
func durationMinutes(t *testing.T, ctx context.Context, tx db.Querier, serviceID string) int {
	t.Helper()
	var d int
	if err := tx.QueryRow(ctx, "SELECT duration_minutes FROM services WHERE id = $1", serviceID).Scan(&d); err != nil {
		t.Fatalf("failed to get service duration: %v", err)
	}
	return d
}

// ============================================================================
// AdminCreateBookingForUserHandler — overlap detection
// ============================================================================

// TestAdminCreateBooking_OverlapWithConfirmed verifies that creating a booking
// at a time that overlaps an existing confirmed booking returns 409.
func TestAdminCreateBooking_OverlapWithConfirmed(t *testing.T) {
	t.Parallel()
	ctx, tx := testutils.SetupTestTx(t)

	userID, err := fixtures.CreateTestUser(tx)
	if err != nil {
		t.Fatalf("failed to create user: %v", err)
	}
	adminID, err := fixtures.CreateTestAdminUser(tx)
	if err != nil {
		t.Fatalf("failed to create admin: %v", err)
	}
	serviceID, err := fixtures.CreateTestService(tx)
	if err != nil {
		t.Fatalf("failed to create service: %v", err)
	}
	dur := durationMinutes(t, ctx, tx, serviceID)

	baseTime := weekdayTime(time.Wednesday, 10)

	// Create an existing confirmed booking
	existingID, err := fixtures.CreateTestBookingAtTime(tx, userID, serviceID, baseTime)
	if err != nil {
		t.Fatalf("failed to create existing booking: %v", err)
	}
	_, err = tx.Exec(ctx, "UPDATE bookings SET status = 'confirmed' WHERE id = $1", existingID)
	if err != nil {
		t.Fatalf("failed to confirm existing booking: %v", err)
	}

	// Try to create a new booking overlapping the existing one (starts 15 min
	// after the existing booking starts but before it ends).
	overlapTime := baseTime.Add(time.Duration(dur/2) * time.Minute)

	body := AdminCreateBookingForUserRequest{
		UserID:     userID,
		StartTime:  overlapTime,
		ServiceIDs: []string{serviceID},
	}

	w := serveChiHandler(AdminCreateBookingForUserHandler, "POST", "/", "/", body,
		func(baseCtx context.Context) context.Context {
			baseCtx = context.WithValue(baseCtx, mw.UserRoleKey, "admin")
			baseCtx = context.WithValue(baseCtx, mw.UserIDKey, adminID)
			return db.ContextWithTx(baseCtx, db.TxFromContext(ctx))
		})

	if w.Code != http.StatusConflict {
		t.Errorf("expected 409 for overlapping booking, got %d. body: %s", w.Code, w.Body.String())
	}

	// Verify the existing booking was NOT evicted (no pending_release eviction
	// since the existing booking is confirmed, not pending_release).
	var status string
	err = tx.QueryRow(ctx, "SELECT status FROM bookings WHERE id = $1", existingID).Scan(&status)
	if err != nil {
		t.Fatalf("failed to query existing booking: %v", err)
	}
	if status != "confirmed" {
		t.Errorf("expected existing booking to remain 'confirmed', got %q", status)
	}
}

// TestAdminCreateBooking_AdjacentBooking_NoOverlap verifies that creating a
// booking at the exact end of an existing booking (adjacent, no gap) is allowed.
func TestAdminCreateBooking_AdjacentBooking_NoOverlap(t *testing.T) {
	t.Parallel()
	ctx, tx := testutils.SetupTestTx(t)

	userID, err := fixtures.CreateTestUser(tx)
	if err != nil {
		t.Fatalf("failed to create user: %v", err)
	}
	adminID, err := fixtures.CreateTestAdminUser(tx)
	if err != nil {
		t.Fatalf("failed to create admin: %v", err)
	}
	serviceID, err := fixtures.CreateTestService(tx)
	if err != nil {
		t.Fatalf("failed to create service: %v", err)
	}
	dur := durationMinutes(t, ctx, tx, serviceID)

	baseTime := weekdayTime(time.Wednesday, 10)

	// Create an existing confirmed booking [10:00, 10:00+dur)
	existingID, err := fixtures.CreateTestBookingAtTime(tx, userID, serviceID, baseTime)
	if err != nil {
		t.Fatalf("failed to create existing booking: %v", err)
	}
	_, err = tx.Exec(ctx, "UPDATE bookings SET status = 'confirmed' WHERE id = $1", existingID)
	if err != nil {
		t.Fatalf("failed to confirm existing booking: %v", err)
	}

	// Create a new booking starting exactly when the existing one ends (adjacent,
	// no overlap).
	adjacentTime := baseTime.Add(time.Duration(dur) * time.Minute)

	body := AdminCreateBookingForUserRequest{
		UserID:     userID,
		StartTime:  adjacentTime,
		ServiceIDs: []string{serviceID},
	}

	w := serveChiHandler(AdminCreateBookingForUserHandler, "POST", "/", "/", body,
		func(baseCtx context.Context) context.Context {
			baseCtx = context.WithValue(baseCtx, mw.UserRoleKey, "admin")
			baseCtx = context.WithValue(baseCtx, mw.UserIDKey, adminID)
			return db.ContextWithTx(baseCtx, db.TxFromContext(ctx))
		})

	if w.Code != http.StatusCreated && w.Code != http.StatusOK {
		t.Errorf("expected 200/201 for adjacent (non-overlapping) booking, got %d. body: %s", w.Code, w.Body.String())
	}
}

// TestAdminCreateBooking_ExactSameStartTime verifies that creating a booking
// at the exact same start time as an existing booking is rejected.
func TestAdminCreateBooking_ExactSameStartTime(t *testing.T) {
	t.Parallel()
	ctx, tx := testutils.SetupTestTx(t)

	userID, err := fixtures.CreateTestUser(tx)
	if err != nil {
		t.Fatalf("failed to create user: %v", err)
	}
	adminID, err := fixtures.CreateTestAdminUser(tx)
	if err != nil {
		t.Fatalf("failed to create admin: %v", err)
	}
	serviceID, err := fixtures.CreateTestService(tx)
	if err != nil {
		t.Fatalf("failed to create service: %v", err)
	}

	baseTime := weekdayTime(time.Wednesday, 10)

	existingID, err := fixtures.CreateTestBookingAtTime(tx, userID, serviceID, baseTime)
	if err != nil {
		t.Fatalf("failed to create existing booking: %v", err)
	}
	_, err = tx.Exec(ctx, "UPDATE bookings SET status = 'confirmed' WHERE id = $1", existingID)
	if err != nil {
		t.Fatalf("failed to confirm existing booking: %v", err)
	}

	// Same exact start time
	body := AdminCreateBookingForUserRequest{
		UserID:     userID,
		StartTime:  baseTime,
		ServiceIDs: []string{serviceID},
	}

	w := serveChiHandler(AdminCreateBookingForUserHandler, "POST", "/", "/", body,
		func(baseCtx context.Context) context.Context {
			baseCtx = context.WithValue(baseCtx, mw.UserRoleKey, "admin")
			baseCtx = context.WithValue(baseCtx, mw.UserIDKey, adminID)
			return db.ContextWithTx(baseCtx, db.TxFromContext(ctx))
		})

	if w.Code != http.StatusConflict {
		t.Errorf("expected 409 for same start time, got %d. body: %s", w.Code, w.Body.String())
	}
}

// ============================================================================
// EditBookingHandler - user-facing edit overlap detection
// ============================================================================

// TestEditBooking_OverlapWithExisting verifies that editing a booking to an
// overlapping time slot returns 409.
func TestEditBooking_OverlapWithExisting(t *testing.T) {
	t.Parallel()
	ctx, tx := testutils.SetupTestTx(t)

	userID, err := fixtures.CreateTestUser(tx)
	if err != nil {
		t.Fatalf("failed to create user: %v", err)
	}
	// Disable deposits for this user so the handler doesn't check deposit limits
	_, err = tx.Exec(ctx, "UPDATE users SET deposits_required = 0 WHERE id = $1", userID)
	if err != nil {
		t.Fatalf("failed to set deposits_required: %v", err)
	}

	serviceID, err := fixtures.CreateTestService(tx)
	if err != nil {
		t.Fatalf("failed to create service: %v", err)
	}
	dur := durationMinutes(t, ctx, tx, serviceID)

	baseTime := weekdayTime(time.Wednesday, 10)
	token := jwt.GenerateUserToken(userID)

	// Create booking A (the one we're editing) at [10:00, 10:00+dur)
	bookingA, err := fixtures.CreateTestBookingAtTime(tx, userID, serviceID, baseTime)
	if err != nil {
		t.Fatalf("failed to create booking A: %v", err)
	}
	_, err = tx.Exec(ctx, "UPDATE bookings SET status = 'confirmed' WHERE id = $1", bookingA)
	if err != nil {
		t.Fatalf("failed to confirm booking A: %v", err)
	}

	// Create booking B at [12:00, 12:00+dur) — far enough away to not interfere initially
	farTime := baseTime.Add(2 * time.Hour)
	bookingB, err := fixtures.CreateTestBookingAtTime(tx, userID, serviceID, farTime)
	if err != nil {
		t.Fatalf("failed to create booking B: %v", err)
	}
	_, err = tx.Exec(ctx, "UPDATE bookings SET status = 'confirmed' WHERE id = $1", bookingB)
	if err != nil {
		t.Fatalf("failed to confirm booking B: %v", err)
	}

	// Now edit booking A to a time that overlaps booking B.
	// Move it to [11:30, 11:30+dur) — booking B is at [12:00, 12:00+dur), so
	// 11:30+dur > 12:00 means overlap.
	overlapTime := farTime.Add(-time.Duration(dur/2) * time.Minute)

	handler := http.HandlerFunc(EditBookingHandler)
	w := makeRequest(handler, "PUT", "/api/bookings/"+bookingA, map[string]interface{}{
		"start_time":  overlapTime.Format(time.RFC3339),
		"service_ids": []string{serviceID},
	}, token, ctx)

	if w.Code != http.StatusConflict {
		t.Errorf("expected 409 for overlapping edit, got %d. body: %s", w.Code, w.Body.String())
	}

	// Verify booking A was NOT updated (still at original time)
	var actualStart time.Time
	err = tx.QueryRow(ctx, "SELECT start_time FROM bookings WHERE id = $1", bookingA).Scan(&actualStart)
	if err != nil {
		t.Fatalf("failed to query booking A: %v", err)
	}
	if !actualStart.Equal(baseTime) {
		t.Errorf("expected booking A start_time to remain %v, got %v", baseTime, actualStart)
	}
}

// TestEditBooking_NonOverlappingEdit_Succeeds verifies that editing a booking
// to a non-overlapping time succeeds.
func TestEditBooking_NonOverlappingEdit_Succeeds(t *testing.T) {
	t.Parallel()
	ctx, tx := testutils.SetupTestTx(t)

	userID, err := fixtures.CreateTestUser(tx)
	if err != nil {
		t.Fatalf("failed to create user: %v", err)
	}
	_, err = tx.Exec(ctx, "UPDATE users SET deposits_required = 0 WHERE id = $1", userID)
	if err != nil {
		t.Fatalf("failed to set deposits_required: %v", err)
	}

	serviceID, err := fixtures.CreateTestService(tx)
	if err != nil {
		t.Fatalf("failed to create service: %v", err)
	}
	dur := durationMinutes(t, ctx, tx, serviceID)

	baseTime := weekdayTime(time.Wednesday, 10)
	newTime := baseTime.Add(24 * time.Hour) // Next day, far from any conflict
	token := jwt.GenerateUserToken(userID)

	bookingID, err := fixtures.CreateTestBookingAtTime(tx, userID, serviceID, baseTime)
	if err != nil {
		t.Fatalf("failed to create booking: %v", err)
	}
	_, err = tx.Exec(ctx, "UPDATE bookings SET status = 'confirmed' WHERE id = $1", bookingID)
	if err != nil {
		t.Fatalf("failed to confirm booking: %v", err)
	}

	_ = dur

	handler := http.HandlerFunc(EditBookingHandler)
	w := makeRequest(handler, "PUT", "/api/bookings/"+bookingID, map[string]interface{}{
		"start_time":  newTime.Format(time.RFC3339),
		"service_ids": []string{serviceID},
	}, token, ctx)

	if w.Code != http.StatusOK {
		t.Errorf("expected 200 for non-overlapping edit, got %d. body: %s", w.Code, w.Body.String())
	}
}

// ============================================================================
// RequestEditHandler — auto-approve path overlap detection
// ============================================================================

// TestRequestEditHandler_AutoApprove_OverlapDetected verifies that the
// auto-approve path rejects a request that would create an overlap.
// Requests with new_start_time and >48h to the event trigger auto-approval
// which runs the overlap check inline.
func TestRequestEditHandler_AutoApprove_OverlapDetected(t *testing.T) {
	t.Parallel()
	ctx, tx := testutils.SetupTestTx(t)

	userID, err := fixtures.CreateTestUser(tx)
	if err != nil {
		t.Fatalf("failed to create user: %v", err)
	}
	_, err = tx.Exec(ctx, "UPDATE users SET deposits_required = 0 WHERE id = $1", userID)
	if err != nil {
		t.Fatalf("failed to set deposits_required: %v", err)
	}
	serviceID, err := fixtures.CreateTestService(tx)
	if err != nil {
		t.Fatalf("failed to create service: %v", err)
	}
	dur := durationMinutes(t, ctx, tx, serviceID)

	baseTime := weekdayTime(time.Wednesday, 10)
	token := jwt.GenerateUserToken(userID)

	// Booking A — user's existing confirmed booking at [10:00, 10:00+dur)
	bookingA, err := fixtures.CreateTestBookingAtTime(tx, userID, serviceID, baseTime)
	if err != nil {
		t.Fatalf("failed to create booking A: %v", err)
	}
	_, err = tx.Exec(ctx, "UPDATE bookings SET status = 'confirmed' WHERE id = $1", bookingA)
	if err != nil {
		t.Fatalf("failed to confirm booking A: %v", err)
	}

	// Booking B — at a far-away time (so auto-approve triggers when we set
	// new_start_time on an existing confirmed booking >48h out)
	bookingBTime := baseTime.Add(48 * time.Hour)
	bookingB, err := fixtures.CreateTestBookingAtTime(tx, userID, serviceID, bookingBTime)
	if err != nil {
		t.Fatalf("failed to create booking B: %v", err)
	}
	_, err = tx.Exec(ctx, "UPDATE bookings SET status = 'confirmed' WHERE id = $1", bookingB)
	if err != nil {
		t.Fatalf("failed to confirm booking B: %v", err)
	}

	// Submit edit request with a new_start_time that overlaps A.
	// Since the edit request is >48h before the booking event, the auto-approve
	// path runs the overlap check and should reject with 409.
	overlapTime := baseTime.Add(time.Duration(dur/2) * time.Minute)

	handler := http.HandlerFunc(RequestEditHandler)
	w := makeRequest(handler, "POST", "/api/bookings/"+bookingB+"/edit-request", map[string]interface{}{
		"new_start_time": overlapTime.Format(time.RFC3339),
	}, token, ctx)

	if w.Code != http.StatusConflict {
		t.Errorf("expected 409 for overlapping auto-approve, got %d. body: %s", w.Code, w.Body.String())
	}
}

// ============================================================================
// UpdateBookingServicesHandler — extending duration into existing booking
// ============================================================================

// TestUpdateBookingServices_ExtendOverlapsExisting verifies that extending a
// booking's duration (by adding a second service) into an existing booking's
// slot returns 409.
func TestUpdateBookingServices_ExtendOverlapsExisting(t *testing.T) {
	t.Parallel()
	ctx, tx := testutils.SetupTestTx(t)

	userID, err := fixtures.CreateTestUser(tx)
	if err != nil {
		t.Fatalf("failed to create user: %v", err)
	}
	adminID, err := fixtures.CreateTestAdminUser(tx)
	if err != nil {
		t.Fatalf("failed to create admin: %v", err)
	}
	serviceID, err := fixtures.CreateTestService(tx)
	if err != nil {
		t.Fatalf("failed to create service: %v", err)
	}
	dur := durationMinutes(t, ctx, tx, serviceID)

	baseTime := weekdayTime(time.Wednesday, 10)

	// Booking A — starts at 10:00, duration = dur (ends at 10:00+dur)
	bookingA, err := fixtures.CreateTestBookingAtTime(tx, userID, serviceID, baseTime)
	if err != nil {
		t.Fatalf("failed to create booking A: %v", err)
	}
	_, err = tx.Exec(ctx, "UPDATE bookings SET status = 'confirmed' WHERE id = $1", bookingA)
	if err != nil {
		t.Fatalf("failed to confirm booking A: %v", err)
	}

	// Booking B — starts exactly when A ends (adjacent, no overlap initially)
	adjacentTime := baseTime.Add(time.Duration(dur) * time.Minute)
	bookingB, err := fixtures.CreateTestBookingAtTime(tx, userID, serviceID, adjacentTime)
	if err != nil {
		t.Fatalf("failed to create booking B: %v", err)
	}
	_, err = tx.Exec(ctx, "UPDATE bookings SET status = 'confirmed' WHERE id = $1", bookingB)
	if err != nil {
		t.Fatalf("failed to confirm booking B: %v", err)
	}

	// Create a second service with short duration (30 min) that, when added to
	// A, would make A extend INTO B's slot.
	shortSvcID, err := fixtures.CreateTestServiceWithDuration(tx, 30)
	if err != nil {
		t.Fatalf("failed to create short service: %v", err)
	}

	// Try to add the second service to booking A — this extends A's duration
	// to dur+30, which exceeds the gap to booking B.
	w := serveChiHandler(UpdateBookingServicesHandler, "PUT", "/"+bookingA, "/{id}", map[string]interface{}{
		"service_ids": []string{serviceID, shortSvcID},
	}, func(baseCtx context.Context) context.Context {
		baseCtx = context.WithValue(baseCtx, mw.UserRoleKey, "admin")
		baseCtx = context.WithValue(baseCtx, mw.UserIDKey, adminID)
		return db.ContextWithTx(baseCtx, db.TxFromContext(ctx))
	})

	if w.Code != http.StatusConflict {
		t.Errorf("expected 409 for extending into existing booking, got %d. body: %s", w.Code, w.Body.String())
	}
}

// TestUpdateBookingServices_ExtendNoOverlap_Succeeds verifies that extending a
// booking's duration without overlapping another booking succeeds.
func TestUpdateBookingServices_ExtendNoOverlap_Succeeds(t *testing.T) {
	t.Parallel()
	ctx, tx := testutils.SetupTestTx(t)

	userID, err := fixtures.CreateTestUser(tx)
	if err != nil {
		t.Fatalf("failed to create user: %v", err)
	}
	adminID, err := fixtures.CreateTestAdminUser(tx)
	if err != nil {
		t.Fatalf("failed to create admin: %v", err)
	}
	serviceID, err := fixtures.CreateTestService(tx)
	if err != nil {
		t.Fatalf("failed to create service: %v", err)
	}
	dur := durationMinutes(t, ctx, tx, serviceID)

	baseTime := weekdayTime(time.Wednesday, 10)

	// Booking A — starts at 10:00
	bookingA, err := fixtures.CreateTestBookingAtTime(tx, userID, serviceID, baseTime)
	if err != nil {
		t.Fatalf("failed to create booking A: %v", err)
	}
	_, err = tx.Exec(ctx, "UPDATE bookings SET status = 'confirmed' WHERE id = $1", bookingA)
	if err != nil {
		t.Fatalf("failed to confirm booking A: %v", err)
	}

	// Booking B — starts 3 hours later (plenty of room)
	farTime := baseTime.Add(3 * time.Hour)
	bookingB, err := fixtures.CreateTestBookingAtTime(tx, userID, serviceID, farTime)
	if err != nil {
		t.Fatalf("failed to create booking B: %v", err)
	}
	_, err = tx.Exec(ctx, "UPDATE bookings SET status = 'confirmed' WHERE id = $1", bookingB)
	if err != nil {
		t.Fatalf("failed to confirm booking B: %v", err)
	}

	_ = dur

	// Create a second service with 30 min duration — A would be dur+30,
	// which still leaves plenty of gap before B.
	shortSvcID, err := fixtures.CreateTestServiceWithDuration(tx, 30)
	if err != nil {
		t.Fatalf("failed to create short service: %v", err)
	}

	w := serveChiHandler(UpdateBookingServicesHandler, "PUT", "/"+bookingA, "/{id}", map[string]interface{}{
		"service_ids": []string{serviceID, shortSvcID},
	}, func(baseCtx context.Context) context.Context {
		baseCtx = context.WithValue(baseCtx, mw.UserRoleKey, "admin")
		baseCtx = context.WithValue(baseCtx, mw.UserIDKey, adminID)
		return db.ContextWithTx(baseCtx, db.TxFromContext(ctx))
	})

	if w.Code != http.StatusOK {
		t.Errorf("expected 200 for extending without overlap, got %d. body: %s", w.Code, w.Body.String())
	}
}

// ============================================================================
// ReserveSlotHandler — overlap detection (existing test was checking for
// regression, this strengthens coverage)
// ============================================================================

// TestReserveSlot_OverlapWithExistingBooking confirms that the reserve endpoint
// returns 409 when the requested slot overlaps a confirmed booking.
func TestReserveSlot_OverlapWithExistingBooking(t *testing.T) {
	t.Parallel()
	ctx, tx := testutils.SetupTestTx(t)

	serviceID, err := fixtures.CreateTestService(tx)
	if err != nil {
		t.Fatalf("failed to create service: %v", err)
	}

	userID, err := fixtures.CreateTestUser(tx)
	if err != nil {
		t.Fatalf("failed to create user: %v", err)
	}

	baseTime := weekdayTime(time.Wednesday, 10)

	_, err = tx.Exec(ctx, `
		INSERT INTO bookings (user_id, start_time, status, deposit_required)
		VALUES ($1, $2, 'confirmed', false)
	`, userID, baseTime)
	if err != nil {
		t.Fatalf("failed to create booking: %v", err)
	}

	w := makeReserveRequest(ctx, "POST", "/api/bookings/reserve", ReserveSlotRequest{
		StartTime:  baseTime,
		ServiceIDs: []string{serviceID},
	}, "")
	if w.Code != http.StatusConflict {
		t.Errorf("expected 409 for overlapping booking, got %d. body: %s", w.Code, w.Body.String())
	}
}

// ============================================================================
// AdminReserveSlotHandler — overlap detection
// ============================================================================

// TestAdminReserveSlot_OverlapWithExistingBooking verifies that admin reserve
// returns 409 when the slot overlaps a confirmed booking.
func TestAdminReserveSlot_OverlapWithExistingBooking(t *testing.T) {
	t.Parallel()
	ctx, tx := testutils.SetupTestTx(t)

	serviceID, err := fixtures.CreateTestService(tx)
	if err != nil {
		t.Fatalf("failed to create service: %v", err)
	}

	userID, err := fixtures.CreateTestUser(tx)
	if err != nil {
		t.Fatalf("failed to create user: %v", err)
	}

	baseTime := weekdayTime(time.Wednesday, 10)

	_, err = tx.Exec(ctx, `
		INSERT INTO bookings (user_id, start_time, status)
		VALUES ($1, $2, 'confirmed')
	`, userID, baseTime)
	if err != nil {
		t.Fatalf("failed to create booking: %v", err)
	}

	w := serveChiHandler(AdminReserveSlotHandler, "POST", "/", "/", AdminReserveSlotRequest{
		StartTime:       baseTime,
		ServiceIDs:      []string{serviceID},
		ReservationType: "callin",
	}, func(baseCtx context.Context) context.Context {
		baseCtx = context.WithValue(baseCtx, mw.UserRoleKey, "admin")
		baseCtx = context.WithValue(baseCtx, mw.UserIDKey, userID)
		return db.ContextWithTx(baseCtx, db.TxFromContext(ctx))
	})

	if w.Code != http.StatusConflict {
		t.Errorf("expected 409 for overlapping admin reserve, got %d. body: %s", w.Code, w.Body.String())
	}
}

// ============================================================================
// AdminRescheduleBookingHandler — overlap detection
// ============================================================================

// TestAdminRescheduleBooking_OverlapWithConfirmed verifies that rescheduling
// a booking to an overlapping time returns 409.
func TestAdminRescheduleBooking_OverlapWithConfirmed(t *testing.T) {
	t.Parallel()
	ctx, tx := testutils.SetupTestTx(t)

	userID, err := fixtures.CreateTestUser(tx)
	if err != nil {
		t.Fatalf("failed to create user: %v", err)
	}
	adminID, err := fixtures.CreateTestAdminUser(tx)
	if err != nil {
		t.Fatalf("failed to create admin: %v", err)
	}
	serviceID, err := fixtures.CreateTestService(tx)
	if err != nil {
		t.Fatalf("failed to create service: %v", err)
	}
	dur := durationMinutes(t, ctx, tx, serviceID)

	baseTime := weekdayTime(time.Wednesday, 10)

	// Booking A — occupies [10:00, 10:00+dur)
	bookingA, err := fixtures.CreateTestBookingAtTime(tx, userID, serviceID, baseTime)
	if err != nil {
		t.Fatalf("failed to create booking A: %v", err)
	}
	_, err = tx.Exec(ctx, "UPDATE bookings SET status = 'confirmed' WHERE id = $1", bookingA)
	if err != nil {
		t.Fatalf("failed to confirm booking A: %v", err)
	}

	// Booking B — later slot, will be rescheduled INTO A's slot
	bookingBTime := baseTime.Add(48 * time.Hour)
	bookingB, err := fixtures.CreateTestBookingAtTime(tx, userID, serviceID, bookingBTime)
	if err != nil {
		t.Fatalf("failed to create booking B: %v", err)
	}
	_, err = tx.Exec(ctx, "UPDATE bookings SET status = 'confirmed' WHERE id = $1", bookingB)
	if err != nil {
		t.Fatalf("failed to confirm booking B: %v", err)
	}

	// Try to reschedule B into A's slot (overlap)
	overlapTime := baseTime.Add(time.Duration(dur/2) * time.Minute)

	body := map[string]interface{}{
		"start_time": overlapTime.Format(time.RFC3339),
	}

	w := serveChiHandler(AdminRescheduleBookingHandler, "PUT", "/"+bookingB+"/reschedule", "/{id}/reschedule", body,
		func(baseCtx context.Context) context.Context {
			baseCtx = context.WithValue(baseCtx, mw.UserRoleKey, "admin")
			baseCtx = context.WithValue(baseCtx, mw.UserIDKey, adminID)
			return db.ContextWithTx(baseCtx, db.TxFromContext(ctx))
		})

	if w.Code != http.StatusConflict {
		t.Errorf("expected 409 for reschedule overlapping booking, got %d. body: %s", w.Code, w.Body.String())
	}
}

// ============================================================================
// ConfirmBookingHandler — overlap detection
// ============================================================================

// TestConfirmBooking_OverlapWithConfirmed verifies that confirming a booking
// that would overlap an existing confirmed booking returns 409.
func TestConfirmBooking_OverlapWithConfirmed(t *testing.T) {
	t.Parallel()
	ctx, tx := testutils.SetupTestTx(t)

	userID, err := fixtures.CreateTestUser(tx)
	if err != nil {
		t.Fatalf("failed to create user: %v", err)
	}
	adminID, err := fixtures.CreateTestAdminUser(tx)
	if err != nil {
		t.Fatalf("failed to create admin: %v", err)
	}
	serviceID, err := fixtures.CreateTestService(tx)
	if err != nil {
		t.Fatalf("failed to create service: %v", err)
	}
	dur := durationMinutes(t, ctx, tx, serviceID)

	baseTime := weekdayTime(time.Wednesday, 10)

	// Booking A — confirmed, occupies [10:00, 10:00+dur)
	bookingA, err := fixtures.CreateTestBookingAtTime(tx, userID, serviceID, baseTime)
	if err != nil {
		t.Fatalf("failed to create booking A: %v", err)
	}
	_, err = tx.Exec(ctx, "UPDATE bookings SET status = 'confirmed' WHERE id = $1", bookingA)
	if err != nil {
		t.Fatalf("failed to confirm booking A: %v", err)
	}

	// Booking B — pending, at the same time (would overlap if confirmed)
	bookingB, err := fixtures.CreateTestBookingAtTime(tx, userID, serviceID, baseTime.Add(15*time.Minute))
	if err != nil {
		t.Fatalf("failed to create booking B: %v", err)
	}
	_, err = tx.Exec(ctx, "UPDATE bookings SET status = 'pending' WHERE id = $1", bookingB)
	if err != nil {
		t.Fatalf("failed to set booking B to pending: %v", err)
	}

	_ = dur

	// Confirm booking B — should be rejected because it would overlap A
	w := serveChiHandler(ConfirmBookingHandler, "POST", "/"+bookingB+"/confirm", "/{id}/confirm", map[string]interface{}{},
		func(baseCtx context.Context) context.Context {
			baseCtx = context.WithValue(baseCtx, mw.UserRoleKey, "admin")
			baseCtx = context.WithValue(baseCtx, mw.UserIDKey, adminID)
			return db.ContextWithTx(baseCtx, db.TxFromContext(ctx))
		})

	if w.Code != http.StatusConflict {
		t.Errorf("expected 409 for confirm overlapping booking, got %d. body: %s", w.Code, w.Body.String())
	}
}

// TestConfirmBooking_NoOverlap_Succeeds verifies that confirming a non-overlapping
// pending booking succeeds.
func TestConfirmBooking_NoOverlap_Succeeds(t *testing.T) {
	t.Parallel()
	ctx, tx := testutils.SetupTestTx(t)

	userID, err := fixtures.CreateTestUser(tx)
	if err != nil {
		t.Fatalf("failed to create user: %v", err)
	}
	adminID, err := fixtures.CreateTestAdminUser(tx)
	if err != nil {
		t.Fatalf("failed to create admin: %v", err)
	}
	serviceID, err := fixtures.CreateTestService(tx)
	if err != nil {
		t.Fatalf("failed to create service: %v", err)
	}
	dur := durationMinutes(t, ctx, tx, serviceID)

	baseTime := weekdayTime(time.Wednesday, 10)

	// Existing confirmed booking
	existingID, err := fixtures.CreateTestBookingAtTime(tx, userID, serviceID, baseTime)
	if err != nil {
		t.Fatalf("failed to create existing booking: %v", err)
	}
	_, err = tx.Exec(ctx, "UPDATE bookings SET status = 'confirmed' WHERE id = $1", existingID)
	if err != nil {
		t.Fatalf("failed to confirm existing booking: %v", err)
	}

	// Pending booking at a non-overlapping time (adjacent, exactly when A ends)
	pendingStart := baseTime.Add(time.Duration(dur) * time.Minute)
	pendingID, err := fixtures.CreateTestBookingAtTime(tx, userID, serviceID, pendingStart)
	if err != nil {
		t.Fatalf("failed to create pending booking: %v", err)
	}
	_, err = tx.Exec(ctx, "UPDATE bookings SET status = 'pending' WHERE id = $1", pendingID)
	if err != nil {
		t.Fatalf("failed to set pending: %v", err)
	}

	w := serveChiHandler(ConfirmBookingHandler, "POST", "/"+pendingID+"/confirm", "/{id}/confirm", map[string]interface{}{},
		func(baseCtx context.Context) context.Context {
			baseCtx = context.WithValue(baseCtx, mw.UserRoleKey, "admin")
			baseCtx = context.WithValue(baseCtx, mw.UserIDKey, adminID)
			return db.ContextWithTx(baseCtx, db.TxFromContext(ctx))
		})

	if w.Code != http.StatusOK {
		t.Errorf("expected 200 for confirming non-overlapping booking, got %d. body: %s", w.Code, w.Body.String())
	}
}

// ============================================================================
// AdminApproveEditRequestHandler — overlap at approval time
// ============================================================================

// TestAdminApproveEditRequest_OverlapWithBooking is already tested in
// edit_requests_test.go:1607. This test re-verifies the same scenario with
// the updated handler to guard against regression.
func TestAdminApproveEditRequest_OverlapWithBooking_Regression(t *testing.T) {
	t.Parallel()
	ctx, tx := testutils.SetupTestTx(t)

	userID, err := fixtures.CreateTestUser(tx)
	if err != nil {
		t.Fatalf("failed to create user: %v", err)
	}
	_, err = tx.Exec(ctx, "UPDATE users SET deposits_required = 0 WHERE id = $1", userID)
	if err != nil {
		t.Fatalf("failed to set deposits_required: %v", err)
	}
	serviceID, err := fixtures.CreateTestService(tx)
	if err != nil {
		t.Fatalf("failed to create service: %v", err)
	}
	dur := durationMinutes(t, ctx, tx, serviceID)

	// Use <48h from now so RequestEditHandler does NOT auto-approve
	nearTime := time.Now().Add(40 * time.Hour)
	nearTime = time.Date(nearTime.Year(), nearTime.Month(), nearTime.Day(), nearTime.Hour(), 0, 0, 0, nearTime.Location())
	switch nearTime.Weekday() {
	case time.Sunday:
		nearTime = nearTime.AddDate(0, 0, 2)
	case time.Monday:
		nearTime = nearTime.AddDate(0, 0, 1)
	}

	token := jwt.GenerateUserToken(userID)

	bookingA, err := fixtures.CreateTestBookingAtTime(tx, userID, serviceID, nearTime)
	if err != nil {
		t.Fatalf("failed to create booking A: %v", err)
	}
	_, err = tx.Exec(ctx, "UPDATE bookings SET status = 'confirmed' WHERE id = $1", bookingA)
	if err != nil {
		t.Fatalf("failed to confirm booking A: %v", err)
	}

	bookingBTime := nearTime.Add(2 * time.Hour)
	bookingB, err := fixtures.CreateTestBookingAtTime(tx, userID, serviceID, bookingBTime)
	if err != nil {
		t.Fatalf("failed to create booking B: %v", err)
	}
	_, err = tx.Exec(ctx, "UPDATE bookings SET status = 'confirmed' WHERE id = $1", bookingB)
	if err != nil {
		t.Fatalf("failed to confirm booking B: %v", err)
	}

	overlapTime := nearTime.Add(time.Duration(dur/2) * time.Minute)
	handler := http.HandlerFunc(RequestEditHandler)
	w := makeRequest(handler, "POST", "/api/bookings/"+bookingB+"/edit-request",
		map[string]interface{}{
			"new_start_time": overlapTime.Format(time.RFC3339),
		}, token, ctx)
	if w.Code != http.StatusCreated {
		t.Fatalf("failed to create edit request: %d. body: %s", w.Code, w.Body.String())
	}

	editRequestID := getEditRequestIDFromDB(t, ctx, tx, bookingB)

	approveHandler := http.HandlerFunc(AdminApproveEditRequestHandler)
	w = serveAdminHandler(approveHandler, "POST",
		"/api/admin/bookings/"+bookingB+"/edit-requests/"+editRequestID+"/approve",
		"/api/admin/bookings/{id}/edit-requests/{request_id}/approve", nil, ctx)

	if w.Code != http.StatusConflict {
		t.Errorf("expected 409 for approve overlapping request, got %d. body: %s", w.Code, w.Body.String())
	}
}

// ============================================================================
// AdminCreateBookingForUserHandler — out_of_hours flag tests
// ============================================================================

// TestAdminCreateBooking_OutOfHours_ExceptionalClosed verifies that when
// out_of_hours=true is set, the admin can create a booking during a period
// that would normally be closed due to exceptional hours (holiday closure).
func TestAdminCreateBooking_OutOfHours_ExceptionalClosed(t *testing.T) {
	t.Parallel()
	ctx, tx := testutils.SetupTestTx(t)

	userID, err := fixtures.CreateTestUser(tx)
	if err != nil {
		t.Fatalf("failed to create user: %v", err)
	}
	adminID, err := fixtures.CreateTestAdminUser(tx)
	if err != nil {
		t.Fatalf("failed to create admin: %v", err)
	}
	serviceID, err := fixtures.CreateTestService(tx)
	if err != nil {
		t.Fatalf("failed to create service: %v", err)
	}

	baseTime := weekdayTime(time.Wednesday, 10)

	// Compute the Monday of the week containing baseTime
	weekStart := baseTime.AddDate(0, 0, -int(baseTime.Weekday())+1)
	weekStart = time.Date(weekStart.Year(), weekStart.Month(), weekStart.Day(), 0, 0, 0, 0, time.UTC)
	weekStartStr := weekStart.Format("2006-01-02")

	// Compute weekday in DB format (0=Monday..6=Sunday)
	dbWeekday := int(baseTime.Weekday())
	if dbWeekday == 0 {
		dbWeekday = 6
	} else {
		dbWeekday -= 1
	}

	// Create an exceptional hours group that makes this weekday CLOSED
	var groupID int
	err = tx.QueryRow(ctx, `
		INSERT INTO exceptional_working_hours_groups (name, description)
		VALUES ('Test Closure', 'Exceptional closure for out-of-hours test')
		RETURNING id
	`).Scan(&groupID)
	if err != nil {
		t.Fatalf("failed to create exceptional hours group: %v", err)
	}

	_, err = tx.Exec(ctx, `
		INSERT INTO exceptional_working_hours (group_id, weekday, start_time, end_time, is_open)
		VALUES ($1, $2, '00:00', '23:59', false)
	`, groupID, dbWeekday)
	if err != nil {
		t.Fatalf("failed to seed exceptional hours: %v", err)
	}

	_, err = tx.Exec(ctx, `
		INSERT INTO exceptional_group_applications (group_id, week_start)
		VALUES ($1, $2::date)
	`, groupID, weekStartStr)
	if err != nil {
		t.Fatalf("failed to seed exceptional group application: %v", err)
	}

	// Try creating a booking with out_of_hours=true during the closed exceptional period
	body := AdminCreateBookingForUserRequest{
		UserID:     userID,
		StartTime:  baseTime,
		ServiceIDs: []string{serviceID},
		OutOfHours: true,
	}

	w := serveChiHandler(AdminCreateBookingForUserHandler, "POST", "/", "/", body,
		func(baseCtx context.Context) context.Context {
			baseCtx = context.WithValue(baseCtx, mw.UserRoleKey, "admin")
			baseCtx = context.WithValue(baseCtx, mw.UserIDKey, adminID)
			return db.ContextWithTx(baseCtx, db.TxFromContext(ctx))
		})

	if w.Code != http.StatusCreated && w.Code != http.StatusOK {
		t.Errorf("expected 200/201 for out-of-hours booking during exceptional closure, got %d. body: %s",
			w.Code, w.Body.String())
	}

	// Verify the response body includes out_of_hours=true
	var createResp struct {
		Booking Booking `json:"booking"`
	}
	if err := json.Unmarshal(w.Body.Bytes(), &createResp); err != nil {
		t.Fatalf("failed to parse create response: %v", err)
	}
	if !createResp.Booking.OutOfHours {
		t.Error("expected out_of_hours=true in create booking response")
	}
}

// TestAdminCreateBooking_OutOfHours_WithoutFlag_Fails verifies that when
// out_of_hours=false (default), creating a booking during a closed exceptional
// hours period is rejected with a conflict error.
func TestAdminCreateBooking_OutOfHours_WithoutFlag_Fails(t *testing.T) {
	t.Parallel()
	ctx, tx := testutils.SetupTestTx(t)

	userID, err := fixtures.CreateTestUser(tx)
	if err != nil {
		t.Fatalf("failed to create user: %v", err)
	}
	adminID, err := fixtures.CreateTestAdminUser(tx)
	if err != nil {
		t.Fatalf("failed to create admin: %v", err)
	}
	serviceID, err := fixtures.CreateTestService(tx)
	if err != nil {
		t.Fatalf("failed to create service: %v", err)
	}

	baseTime := weekdayTime(time.Wednesday, 10)

	// Compute the Monday of the week containing baseTime
	weekStart := baseTime.AddDate(0, 0, -int(baseTime.Weekday())+1)
	weekStart = time.Date(weekStart.Year(), weekStart.Month(), weekStart.Day(), 0, 0, 0, 0, time.UTC)
	weekStartStr := weekStart.Format("2006-01-02")

	// Compute weekday in DB format (0=Monday..6=Sunday)
	dbWeekday := int(baseTime.Weekday())
	if dbWeekday == 0 {
		dbWeekday = 6
	} else {
		dbWeekday -= 1
	}

	// Create an exceptional hours group that makes this weekday CLOSED
	var groupID int
	err = tx.QueryRow(ctx, `
		INSERT INTO exceptional_working_hours_groups (name, description)
		VALUES ('Test Closure', 'Exceptional closure for without-flag test')
		RETURNING id
	`).Scan(&groupID)
	if err != nil {
		t.Fatalf("failed to create exceptional hours group: %v", err)
	}

	_, err = tx.Exec(ctx, `
		INSERT INTO exceptional_working_hours (group_id, weekday, start_time, end_time, is_open)
		VALUES ($1, $2, '00:00', '23:59', false)
	`, groupID, dbWeekday)
	if err != nil {
		t.Fatalf("failed to seed exceptional hours: %v", err)
	}

	_, err = tx.Exec(ctx, `
		INSERT INTO exceptional_group_applications (group_id, week_start)
		VALUES ($1, $2::date)
	`, groupID, weekStartStr)
	if err != nil {
		t.Fatalf("failed to seed exceptional group application: %v", err)
	}

	// Try creating a booking WITHOUT out_of_hours during the closed exceptional period
	body := AdminCreateBookingForUserRequest{
		UserID:     userID,
		StartTime:  baseTime,
		ServiceIDs: []string{serviceID},
		// OutOfHours intentionally false (zero value)
	}

	w := serveChiHandler(AdminCreateBookingForUserHandler, "POST", "/", "/", body,
		func(baseCtx context.Context) context.Context {
			baseCtx = context.WithValue(baseCtx, mw.UserRoleKey, "admin")
			baseCtx = context.WithValue(baseCtx, mw.UserIDKey, adminID)
			return db.ContextWithTx(baseCtx, db.TxFromContext(ctx))
		})

	if w.Code != http.StatusConflict {
		t.Errorf("expected 409 for booking during exceptional closure without out_of_hours flag, got %d. body: %s",
			w.Code, w.Body.String())
	}
}

// TestAdminCreateBooking_OutOfHours_OverlapStillChecked verifies that even
// when out_of_hours=true, overlap detection with existing bookings still works.
func TestAdminCreateBooking_OutOfHours_OverlapStillChecked(t *testing.T) {
	t.Parallel()
	ctx, tx := testutils.SetupTestTx(t)

	userID, err := fixtures.CreateTestUser(tx)
	if err != nil {
		t.Fatalf("failed to create user: %v", err)
	}
	adminID, err := fixtures.CreateTestAdminUser(tx)
	if err != nil {
		t.Fatalf("failed to create admin: %v", err)
	}
	serviceID, err := fixtures.CreateTestService(tx)
	if err != nil {
		t.Fatalf("failed to create service: %v", err)
	}
	dur := durationMinutes(t, ctx, tx, serviceID)

	baseTime := weekdayTime(time.Wednesday, 10)

	// Create an existing booking at baseTime (confirmed)
	existingID, err := fixtures.CreateTestBookingAtTime(tx, userID, serviceID, baseTime)
	if err != nil {
		t.Fatalf("failed to create existing booking: %v", err)
	}
	_, err = tx.Exec(ctx, "UPDATE bookings SET status = 'confirmed' WHERE id = $1", existingID)
	if err != nil {
		t.Fatalf("failed to confirm existing booking: %v", err)
	}

	// Try creating an out-of-hours booking that overlaps (starts dur/2 min after)
	overlapTime := baseTime.Add(time.Duration(dur/2) * time.Minute)

	body := AdminCreateBookingForUserRequest{
		UserID:     userID,
		StartTime:  overlapTime,
		ServiceIDs: []string{serviceID},
		OutOfHours: true,
	}

	w := serveChiHandler(AdminCreateBookingForUserHandler, "POST", "/", "/", body,
		func(baseCtx context.Context) context.Context {
			baseCtx = context.WithValue(baseCtx, mw.UserRoleKey, "admin")
			baseCtx = context.WithValue(baseCtx, mw.UserIDKey, adminID)
			return db.ContextWithTx(baseCtx, db.TxFromContext(ctx))
		})

	if w.Code != http.StatusConflict {
		t.Errorf("expected 409 for overlapping out-of-hours booking, got %d. body: %s",
			w.Code, w.Body.String())
	}

	// Verify the existing booking was NOT affected
	var status string
	err = tx.QueryRow(ctx, "SELECT status FROM bookings WHERE id = $1", existingID).Scan(&status)
	if err != nil {
		t.Fatalf("failed to query existing booking: %v", err)
	}
	if status != "confirmed" {
		t.Errorf("expected existing booking to remain 'confirmed', got %q", status)
	}
}

// TestAdminCreateBooking_OutOfHours_TimeBlockerWarning verifies that when
// out_of_hours=true is set and a time blocker overlaps, the booking is still
// created with a warning (rather than being rejected), matching the behavior
// of the non-out-of-hours create flow.
func TestAdminCreateBooking_OutOfHours_TimeBlockerWarning(t *testing.T) {
	t.Parallel()
	ctx, tx := testutils.SetupTestTx(t)

	userID, err := fixtures.CreateTestUser(tx)
	if err != nil {
		t.Fatalf("failed to create user: %v", err)
	}
	adminID, err := fixtures.CreateTestAdminUser(tx)
	if err != nil {
		t.Fatalf("failed to create admin: %v", err)
	}
	serviceID, err := fixtures.CreateTestService(tx)
	if err != nil {
		t.Fatalf("failed to create service: %v", err)
	}

	baseTime := weekdayTime(time.Wednesday, 10)

	// Create a time blocker at the same time as the booking
	_, err = tx.Exec(ctx, `
		INSERT INTO time_blockers (start_time, duration_minutes, description, created_by)
		VALUES ($1, 60, 'Admin Blocked', NULL)
	`, baseTime)
	if err != nil {
		t.Fatalf("failed to create time blocker: %v", err)
	}

	body := AdminCreateBookingForUserRequest{
		UserID:     userID,
		StartTime:  baseTime,
		ServiceIDs: []string{serviceID},
		OutOfHours: true,
	}

	w := serveChiHandler(AdminCreateBookingForUserHandler, "POST", "/", "/", body,
		func(baseCtx context.Context) context.Context {
			baseCtx = context.WithValue(baseCtx, mw.UserRoleKey, "admin")
			baseCtx = context.WithValue(baseCtx, mw.UserIDKey, adminID)
			return db.ContextWithTx(baseCtx, db.TxFromContext(ctx))
		})

	// AdminCreateBookingForUserHandler issues warnings but does not reject
	// for time blocker overlaps — the booking is created with a warning.
	if w.Code != http.StatusCreated && w.Code != http.StatusOK {
		t.Errorf("expected 200/201 (booking created with warning), got %d. body: %s",
			w.Code, w.Body.String())
	}

	// Verify the response includes the time blocker warning
	var createResp struct {
		Warnings []string `json:"warnings"`
	}
	if err := json.Unmarshal(w.Body.Bytes(), &createResp); err != nil {
		t.Fatalf("failed to parse response: %v", err)
	}
	if len(createResp.Warnings) == 0 {
		t.Error("expected warning about time blocker overlap in response")
	}
	foundBlockerWarning := false
	for _, warn := range createResp.Warnings {
		if strings.Contains(warn, "time blocker") {
			foundBlockerWarning = true
			break
		}
	}
	if !foundBlockerWarning {
		t.Errorf("expected warning to mention time blocker, got warnings: %v", createResp.Warnings)
	}
}

// ============================================================================
// Bookings status evolution — overlap edge cases
// ============================================================================

// TestAdminCreateBooking_OverlapWithCancelled_Allowed verifies that creating a
// booking overlapping a cancelled booking is allowed (cancelled bookings are
// excluded from overlap checks).
func TestAdminCreateBooking_OverlapWithCancelled_Allowed(t *testing.T) {
	t.Parallel()
	ctx, tx := testutils.SetupTestTx(t)

	userID, err := fixtures.CreateTestUser(tx)
	if err != nil {
		t.Fatalf("failed to create user: %v", err)
	}
	adminID, err := fixtures.CreateTestAdminUser(tx)
	if err != nil {
		t.Fatalf("failed to create admin: %v", err)
	}
	serviceID, err := fixtures.CreateTestService(tx)
	if err != nil {
		t.Fatalf("failed to create service: %v", err)
	}

	baseTime := weekdayTime(time.Wednesday, 10)

	cancelledID, err := fixtures.CreateTestBookingAtTime(tx, userID, serviceID, baseTime)
	if err != nil {
		t.Fatalf("failed to create booking: %v", err)
	}
	_, err = tx.Exec(ctx, "UPDATE bookings SET status = 'client_cancelled' WHERE id = $1", cancelledID)
	if err != nil {
		t.Fatalf("failed to set client_cancelled: %v", err)
	}

	// Creating a booking overlapping a cancelled one should be OK
	body := AdminCreateBookingForUserRequest{
		UserID:     userID,
		StartTime:  baseTime,
		ServiceIDs: []string{serviceID},
	}

	w := serveChiHandler(AdminCreateBookingForUserHandler, "POST", "/", "/", body,
		func(baseCtx context.Context) context.Context {
			baseCtx = context.WithValue(baseCtx, mw.UserRoleKey, "admin")
			baseCtx = context.WithValue(baseCtx, mw.UserIDKey, adminID)
			return db.ContextWithTx(baseCtx, db.TxFromContext(ctx))
		})

	if w.Code != http.StatusCreated && w.Code != http.StatusOK {
		t.Errorf("expected 200/201 for overlapping completed booking, got %d. body: %s", w.Code, w.Body.String())
	}
}