//
//  ScenarioBPlannerTests.swift
//  SportsTimeTests
//
//  Comprehensive tests for ScenarioBPlanner: Selected games scenario.
//  Tests sliding window logic, anchor game requirements, and route generation.
//

import Testing
import Foundation
import CoreLocation
@testable import SportsTime

@Suite(.serialized)
struct ScenarioBPlannerTests {

    // MARK: - Test Fixtures

    private func makeStadium(
        id: UUID = UUID(),
        name: String,
        city: String,
        state: String,
        latitude: Double,
        longitude: Double,
        sport: Sport = .mlb
    ) -> Stadium {
        Stadium(
            id: id,
            name: name,
            city: city,
            state: state,
            latitude: latitude,
            longitude: longitude,
            capacity: 40000,
            sport: sport
        )
    }

    private func makeGame(
        id: UUID = UUID(),
        stadiumId: UUID,
        date: Date
    ) -> Game {
        Game(
            id: id,
            homeTeamId: UUID(),
            awayTeamId: UUID(),
            stadiumId: stadiumId,
            dateTime: date,
            sport: .mlb,
            season: "2026"
        )
    }

    private func date(_ string: String) -> Date {
        let formatter = DateFormatter()
        formatter.dateFormat = "yyyy-MM-dd HH:mm"
        formatter.timeZone = TimeZone(identifier: "America/Los_Angeles")
        return formatter.date(from: string)!
    }

    private func makeRequest(
        games: [Game],
        stadiums: [UUID: Stadium],
        mustSeeGameIds: Set<UUID>,
        startDate: Date,
        endDate: Date,
        tripDuration: Int? = nil,
        numberOfDrivers: Int = 1
    ) -> PlanningRequest {
        var prefs = TripPreferences(
            startDate: startDate,
            endDate: endDate,
            tripDuration: tripDuration,
            numberOfDrivers: numberOfDrivers
        )
        prefs.mustSeeGameIds = mustSeeGameIds
        return PlanningRequest(
            preferences: prefs,
            availableGames: games,
            teams: [:],
            stadiums: stadiums
        )
    }

    // Standard test stadiums - close together for feasible routes
    private var laStadium: Stadium {
        makeStadium(id: UUID(), name: "Dodger Stadium", city: "Los Angeles", state: "CA", latitude: 34.0739, longitude: -118.2400)
    }

    private var sfStadium: Stadium {
        makeStadium(id: UUID(), name: "Oracle Park", city: "San Francisco", state: "CA", latitude: 37.7786, longitude: -122.3893)
    }

    private var sdStadium: Stadium {
        makeStadium(id: UUID(), name: "Petco Park", city: "San Diego", state: "CA", latitude: 32.7076, longitude: -117.1570)
    }

    private var phoenixStadium: Stadium {
        makeStadium(id: UUID(), name: "Chase Field", city: "Phoenix", state: "AZ", latitude: 33.4455, longitude: -112.0667)
    }

    private var denverStadium: Stadium {
        makeStadium(id: UUID(), name: "Coors Field", city: "Denver", state: "CO", latitude: 39.7559, longitude: -104.9942)
    }

    // MARK: - Basic Validation Tests

    @Test("Empty selected games returns failure")
    func plan_EmptySelectedGames_ReturnsFailure() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let game = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))

        let request = makeRequest(
            games: [game],
            stadiums: [la.id: la],
            mustSeeGameIds: [], // Empty!
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .failure(let failure) = result {
            #expect(failure.reason == .noValidRoutes)
            #expect(failure.violations.contains { $0.type == .selectedGames })
        } else {
            Issue.record("Expected failure for empty selected games")
        }
    }

    @Test("Single selected game returns success")
    func plan_SingleSelectedGame_ReturnsSuccess() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let game = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))

        let request = makeRequest(
            games: [game],
            stadiums: [la.id: la],
            mustSeeGameIds: [game.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            #expect(!options.isEmpty)
            #expect(options.first?.stops.count == 1)
        } else {
            Issue.record("Expected success for single selected game")
        }
    }

    @Test("No date range or duration returns failure")
    func plan_NoDateRangeOrDuration_ReturnsFailure() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let game = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))

        // Use inverted date range to trigger nil dateRange
        let request = makeRequest(
            games: [game],
            stadiums: [la.id: la],
            mustSeeGameIds: [game.id],
            startDate: date("2026-06-30 00:00"),
            endDate: date("2026-06-01 00:00"), // Before start!
            tripDuration: 0 // Zero duration
        )

        let result = planner.plan(request: request)

        if case .failure(let failure) = result {
            #expect(failure.reason == .missingDateRange)
        } else {
            // This test may pass if the system handles it differently
        }
    }

    // MARK: - Selected Games Anchor Tests

    @Test("Selected game appears in all options")
    func plan_SelectedGame_AppearsInAllOptions() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let sf = sfStadium

        let selectedGame = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))
        let otherGame = makeGame(stadiumId: sf.id, date: date("2026-06-16 19:00"))

        let request = makeRequest(
            games: [selectedGame, otherGame],
            stadiums: [la.id: la, sf.id: sf],
            mustSeeGameIds: [selectedGame.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            for option in options {
                let allGameIds = option.stops.flatMap { $0.games }
                #expect(allGameIds.contains(selectedGame.id), "Selected game must be in every option")
            }
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("Multiple selected games all appear in options")
    func plan_MultipleSelectedGames_AllAppearInOptions() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let sf = sfStadium

        let game1 = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))
        let game2 = makeGame(stadiumId: sf.id, date: date("2026-06-17 19:00"))

        let request = makeRequest(
            games: [game1, game2],
            stadiums: [la.id: la, sf.id: sf],
            mustSeeGameIds: [game1.id, game2.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            for option in options {
                let allGameIds = option.stops.flatMap { $0.games }
                #expect(allGameIds.contains(game1.id), "First selected game must be present")
                #expect(allGameIds.contains(game2.id), "Second selected game must be present")
            }
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("Selected games outside date range fail")
    func plan_SelectedGamesOutsideRange_Fails() {
        let planner = ScenarioBPlanner()
        let la = laStadium

        // Game is in July, date range is June
        let game = makeGame(stadiumId: la.id, date: date("2026-07-15 19:00"))

        let request = makeRequest(
            games: [game],
            stadiums: [la.id: la],
            mustSeeGameIds: [game.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .failure = result {
            // Expected
        } else {
            Issue.record("Expected failure when selected games outside date range")
        }
    }

    // MARK: - Sliding Window Tests

    @Test("Trip duration generates sliding windows")
    func plan_TripDuration_GeneratesSlidingWindows() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let sf = sfStadium

        // Selected games on day 5 and day 8
        let game1 = makeGame(stadiumId: la.id, date: date("2026-06-05 19:00"))
        let game2 = makeGame(stadiumId: sf.id, date: date("2026-06-08 19:00"))

        // Bonus games on various days
        let bonus1 = makeGame(stadiumId: la.id, date: date("2026-06-03 19:00"))
        let bonus2 = makeGame(stadiumId: sf.id, date: date("2026-06-12 19:00"))

        let request = makeRequest(
            games: [game1, game2, bonus1, bonus2],
            stadiums: [la.id: la, sf.id: sf],
            mustSeeGameIds: [game1.id, game2.id],
            startDate: date("2026-05-01 00:00"),
            endDate: date("2026-05-01 00:00"), // Trigger sliding window mode
            tripDuration: 10
        )

        let result = planner.plan(request: request)

        // Should succeed - sliding windows cover both selected games
        if case .success(let options) = result {
            #expect(!options.isEmpty)
        } else {
            // May fail due to date range issues - that's ok
        }
    }

    @Test("Short duration fits selected games")
    func plan_ShortDuration_FitsSelectedGames() {
        let planner = ScenarioBPlanner()
        let la = laStadium

        // Games 2 days apart
        let game1 = makeGame(stadiumId: la.id, date: date("2026-06-05 19:00"))
        let game2 = makeGame(stadiumId: la.id, date: date("2026-06-07 19:00"))

        let request = makeRequest(
            games: [game1, game2],
            stadiums: [la.id: la],
            mustSeeGameIds: [game1.id, game2.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59"),
            tripDuration: 3 // Just enough to fit
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            #expect(!options.isEmpty)
        } else {
            Issue.record("Expected success when duration fits games")
        }
    }

    @Test("Duration equal to game span works")
    func plan_DurationEqualsGameSpan_Works() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let sf = sfStadium

        // Games 5 days apart
        let game1 = makeGame(stadiumId: la.id, date: date("2026-06-01 19:00"))
        let game2 = makeGame(stadiumId: sf.id, date: date("2026-06-06 19:00"))

        let request = makeRequest(
            games: [game1, game2],
            stadiums: [la.id: la, sf.id: sf],
            mustSeeGameIds: [game1.id, game2.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-10 23:59")
        )

        let result = planner.plan(request: request)

        if case .success = result {
            // Expected
        } else {
            Issue.record("Expected success when duration equals game span")
        }
    }

    // MARK: - Bonus Games Tests

    @Test("Bonus games added to route")
    func plan_BonusGames_AddedToRoute() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let sf = sfStadium
        let sd = sdStadium

        let selectedGame = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))
        let bonusGame1 = makeGame(stadiumId: sf.id, date: date("2026-06-16 19:00"))
        let bonusGame2 = makeGame(stadiumId: sd.id, date: date("2026-06-14 19:00"))

        let request = makeRequest(
            games: [selectedGame, bonusGame1, bonusGame2],
            stadiums: [la.id: la, sf.id: sf, sd.id: sd],
            mustSeeGameIds: [selectedGame.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            // Should have options with bonus games
            let maxGames = options.map { $0.stops.flatMap { $0.games }.count }.max() ?? 0
            #expect(maxGames > 1, "Should include bonus games in some options")
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("Geographic rationale shows selected and bonus counts")
    func plan_GeographicRationale_ShowsSelectedAndBonusCounts() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let sf = sfStadium

        let selectedGame = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))
        let bonusGame = makeGame(stadiumId: sf.id, date: date("2026-06-17 19:00"))

        let request = makeRequest(
            games: [selectedGame, bonusGame],
            stadiums: [la.id: la, sf.id: sf],
            mustSeeGameIds: [selectedGame.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            // Find option with both games
            if let optionWithBoth = options.first(where: {
                $0.stops.flatMap { $0.games }.count > 1
            }) {
                #expect(optionWithBoth.geographicRationale.contains("selected"))
                #expect(optionWithBoth.geographicRationale.contains("bonus"))
            }
        } else {
            Issue.record("Expected success")
        }
    }

    // MARK: - Travel Segments Tests

    @Test("Two stops have one travel segment")
    func plan_TwoStops_OneTravelSegment() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let sf = sfStadium

        let game1 = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))
        let game2 = makeGame(stadiumId: sf.id, date: date("2026-06-17 19:00"))

        let request = makeRequest(
            games: [game1, game2],
            stadiums: [la.id: la, sf.id: sf],
            mustSeeGameIds: [game1.id, game2.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            for option in options {
                if option.stops.count == 2 {
                    #expect(option.travelSegments.count == 1)
                }
            }
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("Single stop has no travel segments")
    func plan_SingleStop_NoTravelSegments() {
        let planner = ScenarioBPlanner()
        let la = laStadium

        let game = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))

        let request = makeRequest(
            games: [game],
            stadiums: [la.id: la],
            mustSeeGameIds: [game.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            for option in options {
                if option.stops.count == 1 {
                    #expect(option.travelSegments.isEmpty)
                }
            }
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("Travel segment has valid origin and destination")
    func plan_TravelSegment_ValidOriginDestination() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let sf = sfStadium

        let game1 = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))
        let game2 = makeGame(stadiumId: sf.id, date: date("2026-06-17 19:00"))

        let request = makeRequest(
            games: [game1, game2],
            stadiums: [la.id: la, sf.id: sf],
            mustSeeGameIds: [game1.id, game2.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            for option in options {
                for segment in option.travelSegments {
                    #expect(!segment.fromLocation.name.isEmpty || segment.fromLocation.coordinate != nil)
                    #expect(!segment.toLocation.name.isEmpty || segment.toLocation.coordinate != nil)
                }
            }
        } else {
            Issue.record("Expected success")
        }
    }

    // MARK: - Stop Building Tests

    @Test("Games at same stadium grouped into one stop")
    func plan_SameStadiumGames_GroupedIntoOneStop() {
        let planner = ScenarioBPlanner()
        let la = laStadium

        let game1 = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))
        let game2 = makeGame(stadiumId: la.id, date: date("2026-06-16 19:00"))

        let request = makeRequest(
            games: [game1, game2],
            stadiums: [la.id: la],
            mustSeeGameIds: [game1.id, game2.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            if let option = options.first {
                #expect(option.stops.count == 1, "Two games at same stadium = one stop")
                #expect(option.stops.first?.games.count == 2, "Stop should have both games")
            }
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("Stop city matches stadium city")
    func plan_StopCity_MatchesStadiumCity() {
        let planner = ScenarioBPlanner()
        let la = laStadium

        let game = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))

        let request = makeRequest(
            games: [game],
            stadiums: [la.id: la],
            mustSeeGameIds: [game.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            if let stop = options.first?.stops.first {
                #expect(stop.city == "Los Angeles")
                #expect(stop.state == "CA")
            }
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("Stop coordinate matches stadium")
    func plan_StopCoordinate_MatchesStadium() {
        let planner = ScenarioBPlanner()
        let la = laStadium

        let game = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))

        let request = makeRequest(
            games: [game],
            stadiums: [la.id: la],
            mustSeeGameIds: [game.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            if let stop = options.first?.stops.first {
                #expect(stop.coordinate != nil)
                #expect(abs(stop.coordinate!.latitude - 34.0739) < 0.01)
            }
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("Stop arrival date is first game date")
    func plan_StopArrivalDate_IsFirstGameDate() {
        let planner = ScenarioBPlanner()
        let la = laStadium

        let game1 = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))
        let game2 = makeGame(stadiumId: la.id, date: date("2026-06-17 19:00"))

        let request = makeRequest(
            games: [game1, game2],
            stadiums: [la.id: la],
            mustSeeGameIds: [game1.id, game2.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            if let stop = options.first?.stops.first {
                let calendar = Calendar.current
                let arrivalDay = calendar.component(.day, from: stop.arrivalDate)
                #expect(arrivalDay == 15)
            }
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("Stop departure date is last game date")
    func plan_StopDepartureDate_IsLastGameDate() {
        let planner = ScenarioBPlanner()
        let la = laStadium

        let game1 = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))
        let game2 = makeGame(stadiumId: la.id, date: date("2026-06-17 19:00"))

        let request = makeRequest(
            games: [game1, game2],
            stadiums: [la.id: la],
            mustSeeGameIds: [game1.id, game2.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            if let stop = options.first?.stops.first {
                let calendar = Calendar.current
                let departureDay = calendar.component(.day, from: stop.departureDate)
                #expect(departureDay == 17)
            }
        } else {
            Issue.record("Expected success")
        }
    }

    // MARK: - Ranking Tests

    @Test("Options ranked from 1")
    func plan_OptionsRankedFromOne() {
        let planner = ScenarioBPlanner()
        let la = laStadium

        let game = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))

        let request = makeRequest(
            games: [game],
            stadiums: [la.id: la],
            mustSeeGameIds: [game.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            #expect(options.first?.rank == 1)
            for (index, option) in options.enumerated() {
                #expect(option.rank == index + 1)
            }
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("More games ranked higher")
    func plan_MoreGames_RankedHigher() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let sf = sfStadium
        let sd = sdStadium

        let game1 = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))
        let game2 = makeGame(stadiumId: sf.id, date: date("2026-06-16 19:00"))
        let game3 = makeGame(stadiumId: sd.id, date: date("2026-06-14 19:00"))

        let request = makeRequest(
            games: [game1, game2, game3],
            stadiums: [la.id: la, sf.id: sf, sd.id: sd],
            mustSeeGameIds: [game1.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            // Options should be sorted by game count (most first)
            var prevCount = Int.max
            for option in options {
                let count = option.stops.flatMap { $0.games }.count
                #expect(count <= prevCount, "Should be sorted by game count descending")
                prevCount = count
            }
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("Max 10 options returned")
    func plan_Max10OptionsReturned() {
        let planner = ScenarioBPlanner()
        let la = laStadium

        // Create many games in same city to generate many sliding window options
        var games: [Game] = []
        for day in 1...20 {
            games.append(makeGame(
                stadiumId: la.id,
                date: date("2026-06-\(String(format: "%02d", day)) 19:00")
            ))
        }

        // Use tripDuration to enable sliding windows (many possible 5-day windows)
        // With 20 games and 5-day duration, there will be many valid windows
        let request = makeRequest(
            games: games,
            stadiums: [la.id: la],
            mustSeeGameIds: [games[10].id], // Select game in middle
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59"),
            tripDuration: 5
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            #expect(options.count <= 10, "Should return at most 10 options")
            #expect(options.count > 0, "Should return at least one option")
        } else {
            Issue.record("Expected success")
        }
    }

    // MARK: - Driving Constraints Tests

    @Test("Two drivers allows longer routes")
    func plan_TwoDrivers_AllowsLongerRoutes() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let phoenix = phoenixStadium

        let game1 = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))
        let game2 = makeGame(stadiumId: phoenix.id, date: date("2026-06-16 19:00"))

        let request1 = makeRequest(
            games: [game1, game2],
            stadiums: [la.id: la, phoenix.id: phoenix],
            mustSeeGameIds: [game1.id, game2.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59"),
            numberOfDrivers: 1
        )

        let request2 = makeRequest(
            games: [game1, game2],
            stadiums: [la.id: la, phoenix.id: phoenix],
            mustSeeGameIds: [game1.id, game2.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59"),
            numberOfDrivers: 2
        )

        let result1 = planner.plan(request: request1)
        let result2 = planner.plan(request: request2)

        // Both should succeed for short LA-Phoenix trip
        // But 2 drivers gives more flexibility
        if case .success(let options1) = result1, case .success(let options2) = result2 {
            #expect(!options1.isEmpty && !options2.isEmpty)
        }
    }

    @Test("Exceeding daily driving limit fails route")
    func plan_ExceedingDailyLimit_FailsRoute() {
        let planner = ScenarioBPlanner()

        // Create far-apart stadiums
        let nyStadium = makeStadium(
            name: "Yankee Stadium",
            city: "New York",
            state: "NY",
            latitude: 40.8296,
            longitude: -73.9262
        )
        let sfStadium = makeStadium(
            name: "Oracle Park",
            city: "San Francisco",
            state: "CA",
            latitude: 37.7786,
            longitude: -122.3893
        )

        // Games only 1 day apart - impossible to drive
        let game1 = makeGame(stadiumId: nyStadium.id, date: date("2026-06-15 19:00"))
        let game2 = makeGame(stadiumId: sfStadium.id, date: date("2026-06-16 19:00"))

        let request = makeRequest(
            games: [game1, game2],
            stadiums: [nyStadium.id: nyStadium, sfStadium.id: sfStadium],
            mustSeeGameIds: [game1.id, game2.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59"),
            numberOfDrivers: 1
        )

        let result = planner.plan(request: request)

        // Should fail - can't drive NY to SF in one day
        if case .failure = result {
            // Expected
        } else {
            // Also acceptable if it routes but validates later
        }
    }

    // MARK: - Edge Cases

    @Test("All games in future works")
    func plan_AllGamesInFuture_Works() {
        let planner = ScenarioBPlanner()
        let la = laStadium

        let futureDate = Calendar.current.date(byAdding: .year, value: 1, to: Date())!
        let game = makeGame(stadiumId: la.id, date: futureDate)

        let rangeStart = Calendar.current.date(byAdding: .day, value: -30, to: futureDate)!
        let rangeEnd = Calendar.current.date(byAdding: .day, value: 30, to: futureDate)!

        let request = makeRequest(
            games: [game],
            stadiums: [la.id: la],
            mustSeeGameIds: [game.id],
            startDate: rangeStart,
            endDate: rangeEnd
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            #expect(!options.isEmpty)
        } else {
            Issue.record("Expected success for future games")
        }
    }

    @Test("Games in chronological order processed correctly")
    func plan_ChronologicalGames_ProcessedCorrectly() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let sf = sfStadium
        let sd = sdStadium

        let game1 = makeGame(stadiumId: sd.id, date: date("2026-06-14 19:00"))
        let game2 = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))
        let game3 = makeGame(stadiumId: sf.id, date: date("2026-06-17 19:00"))

        let request = makeRequest(
            games: [game1, game2, game3],
            stadiums: [la.id: la, sf.id: sf, sd.id: sd],
            mustSeeGameIds: [game1.id, game2.id, game3.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            #expect(!options.isEmpty)
            // First stop should be SD (earliest game)
            if let firstStop = options.first?.stops.first {
                #expect(firstStop.city == "San Diego")
            }
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("Reverse chronological games reordered")
    func plan_ReverseChronologicalGames_Reordered() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let sf = sfStadium

        // Input games in reverse order
        let game1 = makeGame(stadiumId: sf.id, date: date("2026-06-17 19:00"))
        let game2 = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))

        let request = makeRequest(
            games: [game1, game2], // SF first, LA second
            stadiums: [la.id: la, sf.id: sf],
            mustSeeGameIds: [game1.id, game2.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            #expect(!options.isEmpty)
            // LA should come before SF in route
            if let option = options.first, option.stops.count == 2 {
                #expect(option.stops[0].city == "Los Angeles")
                #expect(option.stops[1].city == "San Francisco")
            }
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("First game start time set correctly")
    func plan_FirstGameStartTime_SetCorrectly() {
        let planner = ScenarioBPlanner()
        let la = laStadium

        let game = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))

        let request = makeRequest(
            games: [game],
            stadiums: [la.id: la],
            mustSeeGameIds: [game.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            if let stop = options.first?.stops.first {
                #expect(stop.firstGameStart != nil)
                // Verify it's the same as the game's dateTime
                #expect(stop.firstGameStart == game.dateTime)
            }
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("Location property has correct name")
    func plan_LocationProperty_CorrectName() {
        let planner = ScenarioBPlanner()
        let la = laStadium

        let game = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))

        let request = makeRequest(
            games: [game],
            stadiums: [la.id: la],
            mustSeeGameIds: [game.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            if let stop = options.first?.stops.first {
                #expect(stop.location.name == "Los Angeles")
            }
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("Empty stadiums dictionary still works")
    func plan_EmptyStadiums_StillWorks() {
        let planner = ScenarioBPlanner()
        let la = laStadium

        let game = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))

        let request = makeRequest(
            games: [game],
            stadiums: [:], // Empty!
            mustSeeGameIds: [game.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        // Should still produce some result (with "Unknown" city)
        if case .success(let options) = result {
            #expect(!options.isEmpty)
            #expect(options.first?.stops.first?.city == "Unknown")
        }
    }

    @Test("Total driving hours computed correctly")
    func plan_TotalDrivingHours_ComputedCorrectly() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let sf = sfStadium

        let game1 = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))
        let game2 = makeGame(stadiumId: sf.id, date: date("2026-06-17 19:00"))

        let request = makeRequest(
            games: [game1, game2],
            stadiums: [la.id: la, sf.id: sf],
            mustSeeGameIds: [game1.id, game2.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            for option in options {
                if option.stops.count > 1 {
                    #expect(option.totalDrivingHours > 0)
                    // LA to SF is ~380 miles, ~6 hours
                    #expect(option.totalDrivingHours < 20, "LA-SF shouldn't take 20 hours")
                }
            }
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("Total distance miles computed correctly")
    func plan_TotalDistanceMiles_ComputedCorrectly() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let sf = sfStadium

        let game1 = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))
        let game2 = makeGame(stadiumId: sf.id, date: date("2026-06-17 19:00"))

        let request = makeRequest(
            games: [game1, game2],
            stadiums: [la.id: la, sf.id: sf],
            mustSeeGameIds: [game1.id, game2.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            for option in options {
                if option.stops.count > 1 {
                    #expect(option.totalDistanceMiles > 0)
                    // LA to SF is ~380 miles (with 1.3x factor ~500 miles)
                    #expect(option.totalDistanceMiles > 300)
                    #expect(option.totalDistanceMiles < 1000)
                }
            }
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("Geographic rationale shows cities")
    func plan_GeographicRationale_ShowsCities() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let sf = sfStadium

        let game1 = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))
        let game2 = makeGame(stadiumId: sf.id, date: date("2026-06-17 19:00"))

        let request = makeRequest(
            games: [game1, game2],
            stadiums: [la.id: la, sf.id: sf],
            mustSeeGameIds: [game1.id, game2.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            if let option = options.first {
                #expect(option.geographicRationale.contains("Los Angeles") ||
                       option.geographicRationale.contains("San Francisco"))
            }
        } else {
            Issue.record("Expected success")
        }
    }

    // MARK: - Complex Scenario Tests

    @Test("Three city route validates chronologically")
    func plan_ThreeCityRoute_ValidatesChronologically() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let sf = sfStadium
        let sd = sdStadium

        let game1 = makeGame(stadiumId: sd.id, date: date("2026-06-14 19:00"))
        let game2 = makeGame(stadiumId: la.id, date: date("2026-06-16 19:00"))
        let game3 = makeGame(stadiumId: sf.id, date: date("2026-06-18 19:00"))

        let request = makeRequest(
            games: [game1, game2, game3],
            stadiums: [la.id: la, sf.id: sf, sd.id: sd],
            mustSeeGameIds: [game1.id, game2.id, game3.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            #expect(!options.isEmpty)
            // Route should be SD → LA → SF (chronological)
            if let option = options.first, option.stops.count == 3 {
                #expect(option.stops[0].city == "San Diego")
                #expect(option.stops[1].city == "Los Angeles")
                #expect(option.stops[2].city == "San Francisco")
            }
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("Partial selection with bonus games")
    func plan_PartialSelection_WithBonusGames() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let sf = sfStadium
        let sd = sdStadium

        let selectedGame = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))
        let bonusGame1 = makeGame(stadiumId: sf.id, date: date("2026-06-17 19:00"))
        let bonusGame2 = makeGame(stadiumId: sd.id, date: date("2026-06-13 19:00"))

        let request = makeRequest(
            games: [selectedGame, bonusGame1, bonusGame2],
            stadiums: [la.id: la, sf.id: sf, sd.id: sd],
            mustSeeGameIds: [selectedGame.id], // Only one selected
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            // All options must have the selected game
            for option in options {
                let allGames = option.stops.flatMap { $0.games }
                #expect(allGames.contains(selectedGame.id))
            }
            // Some options may have bonus games
            let maxGames = options.map { $0.stops.flatMap { $0.games }.count }.max() ?? 0
            #expect(maxGames >= 1)
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("Same day games at different stadiums")
    func plan_SameDayDifferentStadiums_CreatesMultipleStops() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let sf = sfStadium

        // Both games on same day but different stadiums - will fail as impossible to attend both
        let game1 = makeGame(stadiumId: la.id, date: date("2026-06-15 14:00"))
        let game2 = makeGame(stadiumId: sf.id, date: date("2026-06-15 20:00"))

        let request = makeRequest(
            games: [game1, game2],
            stadiums: [la.id: la, sf.id: sf],
            mustSeeGameIds: [game1.id, game2.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        // May fail due to impossibility or generate separate options
        // Either is acceptable
        switch result {
        case .success, .failure:
            break // Either is acceptable
        }
    }

    @Test("Wide date range with few games")
    func plan_WideDateRangeFewGames_Succeeds() {
        let planner = ScenarioBPlanner()
        let la = laStadium

        let game = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))

        // Very wide date range (3 months)
        let request = makeRequest(
            games: [game],
            stadiums: [la.id: la],
            mustSeeGameIds: [game.id],
            startDate: date("2026-04-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            #expect(!options.isEmpty)
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("Narrow date range matches exactly")
    func plan_NarrowDateRange_MatchesExactly() {
        let planner = ScenarioBPlanner()
        let la = laStadium

        let game = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))

        // Narrow date range (1 day)
        let request = makeRequest(
            games: [game],
            stadiums: [la.id: la],
            mustSeeGameIds: [game.id],
            startDate: date("2026-06-15 00:00"),
            endDate: date("2026-06-15 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            #expect(!options.isEmpty)
        } else {
            Issue.record("Expected success for exact date match")
        }
    }

    @Test("All options have valid structure")
    func plan_AllOptions_HaveValidStructure() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let sf = sfStadium

        let game1 = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))
        let game2 = makeGame(stadiumId: sf.id, date: date("2026-06-17 19:00"))

        let request = makeRequest(
            games: [game1, game2],
            stadiums: [la.id: la, sf.id: sf],
            mustSeeGameIds: [game1.id, game2.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            for option in options {
                // Rank is positive
                #expect(option.rank > 0)
                // Stops non-empty
                #expect(!option.stops.isEmpty)
                // Travel segments = stops - 1 (or 0 for single stop)
                if option.stops.count > 1 {
                    #expect(option.travelSegments.count == option.stops.count - 1)
                }
                // Driving hours is reasonable
                #expect(option.totalDrivingHours >= 0)
                // Distance is reasonable
                #expect(option.totalDistanceMiles >= 0)
                // Has rationale
                #expect(!option.geographicRationale.isEmpty)
            }
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("Travel segments are drive mode")
    func plan_TravelSegments_AreDriveMode() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let sf = sfStadium

        let game1 = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))
        let game2 = makeGame(stadiumId: sf.id, date: date("2026-06-17 19:00"))

        let request = makeRequest(
            games: [game1, game2],
            stadiums: [la.id: la, sf.id: sf],
            mustSeeGameIds: [game1.id, game2.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            for option in options {
                for segment in option.travelSegments {
                    #expect(segment.travelMode == .drive)
                }
            }
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("Stops have games array populated")
    func plan_StopsHaveGamesArray_Populated() {
        let planner = ScenarioBPlanner()
        let la = laStadium

        let game = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))

        let request = makeRequest(
            games: [game],
            stadiums: [la.id: la],
            mustSeeGameIds: [game.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            for option in options {
                for stop in option.stops {
                    #expect(!stop.games.isEmpty, "Each stop must have at least one game")
                }
            }
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("Multiple games at single stop sorted by time")
    func plan_MultipleGamesAtStop_SortedByTime() {
        let planner = ScenarioBPlanner()
        let la = laStadium

        let game1 = makeGame(stadiumId: la.id, date: date("2026-06-16 19:00"))
        let game2 = makeGame(stadiumId: la.id, date: date("2026-06-15 19:00"))

        let request = makeRequest(
            games: [game1, game2],
            stadiums: [la.id: la],
            mustSeeGameIds: [game1.id, game2.id],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            if let stop = options.first?.stops.first {
                // game2 (June 15) should be first, game1 (June 16) second
                #expect(stop.games.count == 2)
                #expect(stop.games[0] == game2.id) // Earlier game first
                #expect(stop.games[1] == game1.id) // Later game second
            }
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("Failure contains constraint violation details")
    func plan_Failure_ContainsViolationDetails() {
        let planner = ScenarioBPlanner()

        // Empty selected games should cause failure with details
        let request = makeRequest(
            games: [],
            stadiums: [:],
            mustSeeGameIds: [],
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .failure(let failure) = result {
            #expect(!failure.violations.isEmpty)
            #expect(failure.violations.first?.severity == .error)
            #expect(!failure.violations.first!.description.isEmpty)
        } else {
            Issue.record("Expected failure")
        }
    }

    @Test("Handles many simultaneous selected games")
    func plan_ManySelectedGames_HandlesEfficiently() {
        let planner = ScenarioBPlanner()
        let la = laStadium

        // Create 10 selected games at same stadium
        var games: [Game] = []
        var gameIds: Set<UUID> = []
        for day in 1...10 {
            let game = makeGame(
                stadiumId: la.id,
                date: date("2026-06-\(String(format: "%02d", day)) 19:00")
            )
            games.append(game)
            gameIds.insert(game.id)
        }

        let request = makeRequest(
            games: games,
            stadiums: [la.id: la],
            mustSeeGameIds: gameIds,
            startDate: date("2026-06-01 00:00"),
            endDate: date("2026-06-30 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            #expect(!options.isEmpty)
            // Should be one stop with 10 games
            if let option = options.first {
                #expect(option.stops.count == 1)
                #expect(option.stops.first?.games.count == 10)
            }
        } else {
            Issue.record("Expected success")
        }
    }

    // MARK: - Filler Game Conflict Tests (Phase 09-02)

    @Test("filler game between must-see games is included when feasible")
    func plan_FillerBetweenAnchors_IncludedWhenFeasible() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let sf = sfStadium

        // Create San Jose stadium (between LA and SF)
        let sjStadium = makeStadium(
            name: "San Jose Stadium",
            city: "San Jose",
            state: "CA",
            latitude: 37.3382,
            longitude: -121.8863
        )

        // Must-see: LA Jan 5 1pm, SF Jan 7 7pm
        let laGame = makeGame(stadiumId: la.id, date: date("2026-01-05 13:00"))
        let sfGame = makeGame(stadiumId: sf.id, date: date("2026-01-07 19:00"))

        // Filler: San Jose Jan 6 7pm (between LA and SF, feasible timing)
        let sjGame = makeGame(stadiumId: sjStadium.id, date: date("2026-01-06 19:00"))

        let request = makeRequest(
            games: [laGame, sfGame, sjGame],
            stadiums: [la.id: la, sf.id: sf, sjStadium.id: sjStadium],
            mustSeeGameIds: [laGame.id, sfGame.id],
            startDate: date("2026-01-01 00:00"),
            endDate: date("2026-01-31 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            // Should have a 3-stop route: LA → SJ → SF
            let threeStopOption = options.first { $0.stops.count == 3 }
            #expect(threeStopOption != nil, "Should have route with filler game included")

            if let option = threeStopOption {
                let cities = option.stops.map { $0.city }
                #expect(cities.contains("San Jose"), "Filler city should be included")
            }
        } else {
            Issue.record("Expected success")
        }
    }

    @Test
    func plan_FillerSameDayAsAnchor_Excluded() {
        let planner = ScenarioBPlanner()
        let la = laStadium

        // Create Anaheim stadium (30 miles from LA)
        let anaheimStadium = makeStadium(
            name: "Angel Stadium",
            city: "Anaheim",
            state: "CA",
            latitude: 33.8003,
            longitude: -117.8827
        )

        // Must-see: LA Jan 5 7pm
        let laGame = makeGame(stadiumId: la.id, date: date("2026-01-05 19:00"))

        // Filler: Anaheim Jan 5 7pm (same time, different city - impossible)
        let anaheimGame = makeGame(stadiumId: anaheimStadium.id, date: date("2026-01-05 19:00"))

        let request = makeRequest(
            games: [laGame, anaheimGame],
            stadiums: [la.id: la, anaheimStadium.id: anaheimStadium],
            mustSeeGameIds: [laGame.id],
            startDate: date("2026-01-01 00:00"),
            endDate: date("2026-01-31 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            // All options must include LA game (anchor)
            for option in options {
                let allGameIds = option.stops.flatMap { $0.games }
                #expect(allGameIds.contains(laGame.id), "Anchor game must be present")

                // If both games in same option, they cannot be at same time
                if allGameIds.contains(anaheimGame.id) {
                    Issue.record("Filler game at same time as anchor should be excluded")
                }
            }
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("filler requiring backtracking is excluded or route reordered")
    func plan_FillerRequiringBacktrack_ExcludedOrReordered() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let sf = sfStadium
        let sd = sdStadium // San Diego (south of LA)

        // Must-see: LA Jan 5 7pm, SF Jan 7 7pm (northbound route)
        let laGame = makeGame(stadiumId: la.id, date: date("2026-01-05 19:00"))
        let sfGame = makeGame(stadiumId: sf.id, date: date("2026-01-07 19:00"))

        // Filler: San Diego Jan 6 7pm (south of LA, requires backtrack from northbound route)
        let sdGame = makeGame(stadiumId: sd.id, date: date("2026-01-06 19:00"))

        let request = makeRequest(
            games: [laGame, sfGame, sdGame],
            stadiums: [la.id: la, sf.id: sf, sd.id: sd],
            mustSeeGameIds: [laGame.id, sfGame.id],
            startDate: date("2026-01-01 00:00"),
            endDate: date("2026-01-31 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            // Check if SD is included in any route
            for option in options {
                let cities = option.stops.map { $0.city }
                if cities.contains("San Diego") {
                    // If SD included, route should be reordered: SD → LA → SF
                    // OR it should be a separate option
                    if cities.count == 3 {
                        // Check it's not inefficient backtracking: LA → SF → SD or LA → SD → SF (backtrack)
                        let cityOrder = cities.joined(separator: "→")
                        #expect(
                            cityOrder == "San Diego→Los Angeles→San Francisco",
                            "If filler included, route should avoid backtracking"
                        )
                    }
                }
            }
        } else {
            Issue.record("Expected success")
        }
    }

    @Test("multiple filler options only feasible one included")
    func plan_MultipleFillers_OnlyFeasibleIncluded() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let phoenix = phoenixStadium

        // Create Tucson (between LA and Phoenix)
        let tucsonStadium = makeStadium(
            name: "Tucson Stadium",
            city: "Tucson",
            state: "AZ",
            latitude: 32.2226,
            longitude: -110.9747
        )

        // Must-see: LA Jan 5 1pm, Phoenix Jan 7 7pm (eastbound)
        let laGame = makeGame(stadiumId: la.id, date: date("2026-01-05 13:00"))
        let phoenixGame = makeGame(stadiumId: phoenix.id, date: date("2026-01-07 19:00"))

        // Filler A: SF Jan 6 7pm (300mi north, wrong direction from LA→Phoenix)
        let sfGame = makeGame(stadiumId: sfStadium.id, date: date("2026-01-06 19:00"))

        // Filler B: Tucson Jan 6 7pm (100mi from Phoenix, on the way)
        let tucsonGame = makeGame(stadiumId: tucsonStadium.id, date: date("2026-01-06 19:00"))

        let request = makeRequest(
            games: [laGame, phoenixGame, sfGame, tucsonGame],
            stadiums: [la.id: la, phoenix.id: phoenix, sfStadium.id: sfStadium, tucsonStadium.id: tucsonStadium],
            mustSeeGameIds: [laGame.id, phoenixGame.id],
            startDate: date("2026-01-01 00:00"),
            endDate: date("2026-01-31 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            // Look for routes with 3 stops
            let threeStopOptions = options.filter { $0.stops.count == 3 }

            for option in threeStopOptions {
                let cities = option.stops.map { $0.city }

                // If Tucson included, SF should not be (wrong direction)
                if cities.contains("Tucson") {
                    #expect(!cities.contains("San Francisco"),
                           "Should not include SF when Tucson is better option")
                }

                // If SF included, Tucson should not be (SF is wrong direction)
                if cities.contains("San Francisco") {
                    #expect(!cities.contains("Tucson"),
                           "Should not include Tucson when SF chosen (though Tucson is better)")
                }
            }
        } else {
            Issue.record("Expected success")
        }
    }

    // MARK: - Impossible Geographic Combination Tests (Phase 09-02)

    @Test
    func plan_MustSeeGamesTooFarApart_Fails() {
        let planner = ScenarioBPlanner()

        // Create NY and LA stadiums (2800 miles, 42 hour drive)
        let nyStadium = makeStadium(
            name: "Yankee Stadium",
            city: "New York",
            state: "NY",
            latitude: 40.8296,
            longitude: -73.9262
        )
        let laStadium = self.laStadium

        // Must-see: LA Jan 5 7pm, NY Jan 6 7pm (24 hours available)
        let laGame = makeGame(stadiumId: laStadium.id, date: date("2026-01-05 19:00"))
        let nyGame = makeGame(stadiumId: nyStadium.id, date: date("2026-01-06 19:00"))

        let request = makeRequest(
            games: [laGame, nyGame],
            stadiums: [laStadium.id: laStadium, nyStadium.id: nyStadium],
            mustSeeGameIds: [laGame.id, nyGame.id],
            startDate: date("2026-01-01 00:00"),
            endDate: date("2026-01-31 23:59")
        )

        let result = planner.plan(request: request)

        if case .failure(let failure) = result {
            // Expected - cannot drive 2800mi in 24hr
            #expect(failure.reason == .constraintsUnsatisfiable ||
                   failure.reason == .drivingExceedsLimit)
        } else {
            Issue.record("Expected failure - impossible to drive LA to NY in 24 hours")
        }
    }

    @Test("must-see games in reverse order geographically fail")
    func plan_MustSeeGamesReverseOrder_Fails() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let sf = sfStadium

        // Must-see: SF Jan 5, LA Jan 4
        // Problem: SF game is chronologically after LA, but geographically north
        // This requires backtracking or violates date ordering
        let sfGame = makeGame(stadiumId: sf.id, date: date("2026-01-05 19:00"))
        let laGame = makeGame(stadiumId: la.id, date: date("2026-01-04 19:00"))

        let request = makeRequest(
            games: [sfGame, laGame],
            stadiums: [la.id: la, sf.id: sf],
            mustSeeGameIds: [sfGame.id, laGame.id],
            startDate: date("2026-01-01 00:00"),
            endDate: date("2026-01-31 23:59")
        )

        let result = planner.plan(request: request)

        // This may succeed OR fail depending on routing logic
        // If it succeeds, verify route respects chronology (LA → SF)
        if case .success(let options) = result {
            for option in options {
                if option.stops.count == 2 {
                    // Route should be chronological: LA (Jan 4) → SF (Jan 5)
                    #expect(option.stops[0].city == "Los Angeles")
                    #expect(option.stops[1].city == "San Francisco")
                }
            }
        }
        // Failure is also acceptable
    }

    @Test("three must-see games forming triangle routes or fails")
    func plan_ThreeMustSeeTriangle_RoutesOrFails() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let sf = sfStadium
        let sd = sdStadium

        // Triangle: LA Jan 5, SF Jan 6, SD Jan 7
        // Inefficient: LA→SF→SD requires backtracking south
        // Better: SD→LA→SF (but violates chronology)
        let laGame = makeGame(stadiumId: la.id, date: date("2026-01-05 19:00"))
        let sfGame = makeGame(stadiumId: sf.id, date: date("2026-01-06 19:00"))
        let sdGame = makeGame(stadiumId: sd.id, date: date("2026-01-07 19:00"))

        let request = makeRequest(
            games: [laGame, sfGame, sdGame],
            stadiums: [la.id: la, sf.id: sf, sd.id: sd],
            mustSeeGameIds: [laGame.id, sfGame.id, sdGame.id],
            startDate: date("2026-01-01 00:00"),
            endDate: date("2026-01-31 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            // Should attempt route in chronological order: LA→SF→SD
            let threeStopOption = options.first { $0.stops.count == 3 }
            if let option = threeStopOption {
                // Verify chronological order is respected
                #expect(option.stops[0].city == "Los Angeles")
                #expect(option.stops[1].city == "San Francisco")
                #expect(option.stops[2].city == "San Diego")
            }
        }
        // Failure is also acceptable if deemed too inefficient
    }

    @Test("must-see games exceeding driving constraints fail")
    func plan_MustSeeExceedingDrivingLimit_Fails() {
        let planner = ScenarioBPlanner()
        let la = laStadium
        let phoenix = phoenixStadium

        // Must-see: LA Jan 5 1pm, Phoenix Jan 5 7pm (380 miles, 6hr drive)
        // Constraints: 1 driver, 4hr/day max
        let laGame = makeGame(stadiumId: la.id, date: date("2026-01-05 13:00"))
        let phoenixGame = makeGame(stadiumId: phoenix.id, date: date("2026-01-05 19:00"))

        // Create custom request with reduced driving limit
        var prefs = TripPreferences(
            startDate: date("2026-01-01 00:00"),
            endDate: date("2026-01-31 23:59"),
            tripDuration: nil,
            numberOfDrivers: 1
        )
        prefs.mustSeeGameIds = [laGame.id, phoenixGame.id]
        prefs.maxDrivingHoursPerDriver = 4.0 // Limit to 4 hours

        let request = PlanningRequest(
            preferences: prefs,
            availableGames: [laGame, phoenixGame],
            teams: [:],
            stadiums: [la.id: la, phoenix.id: phoenix]
        )

        let result = planner.plan(request: request)

        if case .failure(let failure) = result {
            // Expected - 6hr drive exceeds 4hr limit
            #expect(failure.reason == .drivingExceedsLimit ||
                   failure.reason == .constraintsUnsatisfiable)
        } else {
            Issue.record("Expected failure - 6hr drive exceeds 4hr daily limit")
        }
    }

    @Test("feasible must-see combination succeeds (sanity)")
    func plan_FeasibleMustSeeCombination_Succeeds() {
        let planner = ScenarioBPlanner()
        let la = laStadium

        // Create Anaheim (30 miles from LA, easy drive)
        let anaheimStadium = makeStadium(
            name: "Angel Stadium",
            city: "Anaheim",
            state: "CA",
            latitude: 33.8003,
            longitude: -117.8827
        )

        // Must-see: LA Jan 5 7pm, Anaheim Jan 7 7pm (plenty of time)
        let laGame = makeGame(stadiumId: la.id, date: date("2026-01-05 19:00"))
        let anaheimGame = makeGame(stadiumId: anaheimStadium.id, date: date("2026-01-07 19:00"))

        let request = makeRequest(
            games: [laGame, anaheimGame],
            stadiums: [la.id: la, anaheimStadium.id: anaheimStadium],
            mustSeeGameIds: [laGame.id, anaheimGame.id],
            startDate: date("2026-01-01 00:00"),
            endDate: date("2026-01-31 23:59")
        )

        let result = planner.plan(request: request)

        if case .success(let options) = result {
            #expect(!options.isEmpty, "Feasible must-see combination should succeed")

            // Verify both games appear in route
            for option in options {
                let allGameIds = option.stops.flatMap { $0.games }
                #expect(allGameIds.contains(laGame.id))
                #expect(allGameIds.contains(anaheimGame.id))
            }
        } else {
            Issue.record("Expected success for feasible must-see combination")
        }
    }
}