//
//  ScenarioEPlannerRealDataTest.swift
//  SportsTimeTests
//
//  Regression test: runs ScenarioEPlanner with real PHI/WSN/BAL data
//  to verify the past-date filtering and full-season coverage fixes.
//

import Foundation
import Testing
import CoreLocation
@testable import SportsTime

@Suite("ScenarioE Real Data Regression")
struct ScenarioEPlannerRealDataTest {

    @Test("PHI + WSN + BAL: returns future regular season results, not spring training")
    func phiWsnBal_returnsFutureRegularSeasonResults() throws {
        let fixture = try FixtureLoader.loadCanonicalGames()
        let rawGames = fixture.games

        // Filter to MLB only
        let mlbRows = rawGames.filter { $0.sport?.lowercased() == "mlb" }
        let games = mlbRows.compactMap(\.domainGame)
        let skippedMLBRows = mlbRows.count - games.count
        #expect(!games.isEmpty, "Expected MLB canonical fixture to contain valid games")

        // Team IDs
        let teamIds: Set<String> = ["team_mlb_phi", "team_mlb_wsn", "team_mlb_bal"]

        // Build stadium map with real coordinates
        let stadiums: [String: Stadium] = [
            "stadium_mlb_citizens_bank_park": Stadium(
                id: "stadium_mlb_citizens_bank_park", name: "Citizens Bank Park",
                city: "Philadelphia", state: "PA",
                latitude: 39.9061, longitude: -75.1665, capacity: 43035, sport: .mlb
            ),
            "stadium_mlb_nationals_park": Stadium(
                id: "stadium_mlb_nationals_park", name: "Nationals Park",
                city: "Washington", state: "DC",
                latitude: 38.8730, longitude: -77.0074, capacity: 41339, sport: .mlb
            ),
            "stadium_mlb_oriole_park_at_camden_yards": Stadium(
                id: "stadium_mlb_oriole_park_at_camden_yards", name: "Oriole Park at Camden Yards",
                city: "Baltimore", state: "MD",
                latitude: 39.2838, longitude: -76.6216, capacity: 45971, sport: .mlb
            ),
            // Spring training stadiums (should be excluded by date filter)
            "stadium_mlb_spring_baycare_ballpark": Stadium(
                id: "stadium_mlb_spring_baycare_ballpark", name: "BayCare Ballpark",
                city: "Clearwater", state: "FL",
                latitude: 27.9781, longitude: -82.7337, capacity: 8500, sport: .mlb
            ),
            "stadium_mlb_spring_cacti_park": Stadium(
                id: "stadium_mlb_spring_cacti_park", name: "CACTI Park",
                city: "West Palm Beach", state: "FL",
                latitude: 26.7367, longitude: -80.1197, capacity: 6671, sport: .mlb
            ),
            "stadium_mlb_spring_ed_smith_stadium": Stadium(
                id: "stadium_mlb_spring_ed_smith_stadium", name: "Ed Smith Stadium",
                city: "Sarasota", state: "FL",
                latitude: 27.3381, longitude: -82.5226, capacity: 8500, sport: .mlb
            ),
        ]

        // Build team map
        let teams: [String: Team] = [
            "team_mlb_phi": Team(id: "team_mlb_phi", name: "Phillies", abbreviation: "PHI",
                                 sport: .mlb, city: "Philadelphia",
                                 stadiumId: "stadium_mlb_citizens_bank_park",
                                 primaryColor: "#E81828", secondaryColor: "#002D72"),
            "team_mlb_wsn": Team(id: "team_mlb_wsn", name: "Nationals", abbreviation: "WSN",
                                 sport: .mlb, city: "Washington",
                                 stadiumId: "stadium_mlb_nationals_park",
                                 primaryColor: "#AB0003", secondaryColor: "#14225A"),
            "team_mlb_bal": Team(id: "team_mlb_bal", name: "Orioles", abbreviation: "BAL",
                                 sport: .mlb, city: "Baltimore",
                                 stadiumId: "stadium_mlb_oriole_park_at_camden_yards",
                                 primaryColor: "#DF4601", secondaryColor: "#000000"),
        ]

        let prefs = TripPreferences(
            planningMode: .teamFirst,
            sports: [.mlb],
            selectedTeamIds: teamIds
        )

        let request = PlanningRequest(
            preferences: prefs,
            availableGames: games,
            teams: teams,
            stadiums: stadiums
        )

        // Use April 2, 2026 as current date (the date the bug was reported)
        let currentDate = TestFixtures.date(year: 2026, month: 4, day: 2, hour: 12)
        let planner = ScenarioEPlanner(currentDate: currentDate)
        let result = planner.plan(request: request)

        guard case .success(let options) = result else {
            if case .failure(let failure) = result {
                Issue.record("Expected success but got failure: \(failure.reason) — \(failure.violations.map(\.description))")
            }
            return
        }

        #expect(!options.isEmpty, "Should find trip options for PHI/WSN/BAL")

        let calendar = Calendar.current
        var output = "\nRESULT> Fixture: \(fixture.url.path)\n"
        output += "RESULT> MLB rows: \(mlbRows.count), skipped malformed MLB rows: \(skippedMLBRows)\n"
        output += "RESULT> ========================================\n"
        output += "RESULT> PHI + WSN + BAL TRIP OPTIONS (\(options.count) results)\n"
        output += "RESULT> ========================================\n\n"

        for option in options {
            let cities = option.stops.map { "\($0.city)" }.joined(separator: " → ")
            let dates = option.stops.map { stop in
                let formatter = DateFormatter()
                formatter.dateFormat = "MMM d"
                return formatter.string(from: stop.arrivalDate)
            }.joined(separator: " → ")

            let gameIds = option.stops.flatMap { $0.games }
            let miles = Int(option.totalDistanceMiles)
            let hours = String(format: "%.1f", option.totalDrivingHours)

            output += "RESULT> Option #\(option.rank): \(cities)\n"
            output += "RESULT>   Dates: \(dates)\n"
            output += "RESULT>   Driving: \(miles) mi, \(hours) hrs\n"
            output += "RESULT>   Games: \(gameIds.count)\n"
            output += "RESULT>   Rationale: \(option.geographicRationale)\n"

            // Verify all games are in the future
            for stop in option.stops {
                #expect(stop.arrivalDate >= calendar.startOfDay(for: currentDate),
                        "Stop in \(stop.city) on \(stop.arrivalDate) should be after April 2, 2026")
            }

            // Verify no spring training stadiums
            for stop in option.stops {
                let isSpringTraining = stop.city == "Clearwater" || stop.city == "Sarasota" || stop.city == "West Palm Beach"
                #expect(!isSpringTraining, "Should not include spring training city: \(stop.city)")
            }

            output += "\n"
        }

        // Verify temporal spread — results should not all be in April
        let months = Set(options.flatMap { $0.stops.map { calendar.component(.month, from: $0.arrivalDate) } })
        output += "RESULT> Months covered: \(months.sorted().map { DateFormatter().monthSymbols[$0 - 1] })\n"
        FileHandle.standardOutput.write(Data(output.utf8))
        #expect(months.count >= 2, "Results should span multiple months across the season")
    }
}

// MARK: - JSON Decoding Helpers

private struct CanonicalGameJSON: Decodable {
    let canonical_id: String?
    let sport: String?
    let season: String?
    let game_datetime_utc: String?
    let home_team_canonical_id: String?
    let away_team_canonical_id: String?
    let stadium_canonical_id: String?
    let is_playoff: Bool?

    var parsedDate: Date {
        guard let game_datetime_utc else { return Date.distantPast }
        let formatter = ISO8601DateFormatter()
        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
        if let date = formatter.date(from: game_datetime_utc) { return date }
        formatter.formatOptions = [.withInternetDateTime]
        return formatter.date(from: game_datetime_utc) ?? Date.distantPast
    }

    var domainGame: Game? {
        guard let canonical_id,
              let home_team_canonical_id,
              let away_team_canonical_id,
              let stadium_canonical_id,
              let season else {
            return nil
        }

        return Game(
            id: canonical_id,
            homeTeamId: home_team_canonical_id,
            awayTeamId: away_team_canonical_id,
            stadiumId: stadium_canonical_id,
            dateTime: parsedDate,
            sport: .mlb,
            season: season,
            isPlayoff: is_playoff ?? false
        )
    }
}

private enum FixtureLoader {
    struct LoadedFixture {
        let url: URL
        let games: [CanonicalGameJSON]
    }

    static func loadCanonicalGames() throws -> LoadedFixture {
        let candidateURLs = [
            repositoryRoot.appendingPathComponent("sportstime_export/games_canonical.json"),
            Bundle(for: BundleToken.self).url(forResource: "games_canonical", withExtension: "json")
        ].compactMap { $0 }

        for url in candidateURLs where FileManager.default.fileExists(atPath: url.path) {
            let data = try Data(contentsOf: url)
            let games = try JSONDecoder().decode([CanonicalGameJSON].self, from: data)
            return LoadedFixture(url: url, games: games)
        }

        throw FixtureLoadError.notFound(candidateURLs.map(\.path))
    }

    private static var repositoryRoot: URL {
        URL(fileURLWithPath: #filePath)
            .deletingLastPathComponent()
            .deletingLastPathComponent()
            .deletingLastPathComponent()
    }
}

private enum FixtureLoadError: LocalizedError {
    case notFound([String])

    var errorDescription: String? {
        switch self {
        case .notFound(let paths):
            let joined = paths.joined(separator: ", ")
            return "Could not find games_canonical.json. Checked: \(joined)"
        }
    }
}

private class BundleToken {}