fuelboard/FuelBoardWidgets/WidgetConfigIntent.swift

import AppIntents
import Foundation

// Per-widget configuration intent (iOS 17+). Every widget instance carries
// its OWN fuel + sort choices, edited directly on the home screen (long-press
// → Edit Widget), independent of what the app has selected. This is what
// allows several FuelBoard widgets to show different fuels/orderings side by
// side.

enum WidgetFuel: String, AppEnum, CaseIterable, Codable {
    case e10
    case e5
    case diesel

    static var typeDisplayRepresentation: TypeDisplayRepresentation = "Fuel"

    static var caseDisplayRepresentations: [WidgetFuel: DisplayRepresentation] = [
        .e10: "Unleaded",
        .e5: "Premium",
        .diesel: "Diesel",
    ]
}

enum WidgetSort: String, AppEnum, CaseIterable, Codable {
    case cheapest
    case closest
    case favourites

    static var typeDisplayRepresentation: TypeDisplayRepresentation = "Sort by"

    static var caseDisplayRepresentations: [WidgetSort: DisplayRepresentation] = [
        .cheapest: "Cheapest",
        .closest: "Closest",
        .favourites: "Favourites",
    ]
}

// Per-widget distance filter. Modelled as an AppEntity (not an AppEnum) so
// the option labels can mirror the app's units setting at render time: an
// AppEnum's caseDisplayRepresentations are STATIC, so the Edit-Widget picker
// would always show "5 miles / 10 miles / 15 miles" regardless of the app's
// km mode. An entity query resolves labels per value, so they can read the
// shared unit preference ("8 km" in km mode).
struct WidgetDistance: AppEntity, Identifiable, Hashable, Codable {
    /// The distance in miles (5/10/15) — the persisted value. Labels are
    /// unit-aware, the stored value stays in miles.
    let id: Int

    var miles: Int { id }

    var displayRepresentation: DisplayRepresentation {
        let unit = FuelStore.loadDistanceUnit()
        let shown = unit.displayMiles(id)
        return DisplayRepresentation(stringLiteral: "\(shown) \(unit.label(for: Double(shown)))")
    }

    static var typeDisplayRepresentation: TypeDisplayRepresentation = "Distance"
    static var defaultQuery = WidgetDistanceQuery()
}

struct WidgetDistanceQuery: EntityQuery {
    func entities(for identifiers: [Int]) async throws -> [WidgetDistance] {
        identifiers.map { WidgetDistance(id: $0) }
    }

    func suggestedEntities() async throws -> [WidgetDistance] {
        FuelStore.stationRadiusOptions.map { WidgetDistance(id: $0) }
    }
}

// A pinned favourite station, selectable on SMALL widgets (which show a single
// station). Reuses FavouriteEntry's id scheme ("fuel|stationID") so the
// provider can resolve the choice straight back to a stored favourite. Only
// surfaced when Sort = Favourites.
struct WidgetFavourite: AppEntity, Identifiable, Hashable, Codable {
    let fuel: FuelType
    let stationID: String

    var id: String { "\(fuel.rawValue)|\(stationID)" }

    var displayRepresentation: DisplayRepresentation {
        let favourites = FuelStore.loadFavourites()
        guard let entry = favourites.first(where: { $0.id == id }) else {
            return DisplayRepresentation(stringLiteral: "Favourite")
        }
        let name = entry.station.name
        // Same station pinned for another fuel? Disambiguate with the fuel tag.
        let hasOtherFuel = favourites.contains {
            $0.station.id == entry.station.id && $0.fuel != entry.fuel
        }
        return DisplayRepresentation(
            stringLiteral: hasOtherFuel ? "\(name) · \(entry.fuel.displayName)" : name
        )
    }

    static var typeDisplayRepresentation: TypeDisplayRepresentation = "Favourite"
    static var defaultQuery = WidgetFavouriteQuery()
}

struct WidgetFavouriteQuery: EntityQuery {
    func entities(for identifiers: [String]) async throws -> [WidgetFavourite] {
        identifiers.map { id in
            let parts = id.split(separator: "|", maxSplits: 1)
            let fuel = FuelType(rawValue: String(parts.first ?? "")) ?? .e10
            return WidgetFavourite(fuel: fuel, stationID: String(parts.last ?? ""))
        }
    }

    func suggestedEntities() async throws -> [WidgetFavourite] {
        FuelStore.loadFavourites().map { WidgetFavourite(fuel: $0.fuel, stationID: $0.station.id) }
    }
}

// The knobs both the medium-list and small-single widget intents expose, so
// one timeline provider can drive either.
protocol WidgetConfigValues {
    var fuel: WidgetFuel { get }
    var sort: WidgetSort { get }
    var distance: WidgetDistance { get }
    /// The pinned favourite (small widget, Favourites sort) — nil when the
    /// widget lists favourites instead (medium).
    var favouriteChoice: WidgetFavourite? { get }
}

struct FuelBoardWidgetConfigurationIntent: WidgetConfigurationIntent, WidgetConfigValues {
    static var title: LocalizedStringResource = "Fuel & Sort"
    static var description = IntentDescription("Which fuel, ordering and search radius this widget shows.")

    @Parameter(title: "Fuel", default: .e10)
    var fuel: WidgetFuel

    @Parameter(title: "Sort by", default: .cheapest)
    var sort: WidgetSort

    @Parameter(title: "Distance", default: WidgetDistance(id: 5))
    var distance: WidgetDistance

    // Medium/list widgets show ALL favourites for the chosen fuel — no
    // pinned-favourite knob.
    var favouriteChoice: WidgetFavourite? { nil }

    /// Edit-Widget UI: the Distance picker only makes sense for Cheapest
    /// ordering — Closest is inherently "nearest within range" and Favourites
    /// is not radius-bound. Show it for Cheapest only; hide for both others.
    static var parameterSummary: some ParameterSummary {
        When(\.$sort, .equalTo, WidgetSort.cheapest) {
            Summary("Show \(\.$fuel) by \(\.$sort) within \(\.$distance)") {
                \.$fuel
                \.$sort
                \.$distance
            }
        } otherwise: {
            When(\.$sort, .equalTo, WidgetSort.favourites) {
                Summary("Show \(\.$fuel) favourites") {
                    \.$fuel
                    \.$sort
                }
            } otherwise: {
                Summary("Show \(\.$fuel) by \(\.$sort)") {
                    \.$fuel
                    \.$sort
                }
            }
        }
    }
}

// SMALL widget intent: same knobs as the list widget, PLUS a pinned-favourite
// picker for Favourites sort (a small widget shows exactly ONE station, so the
// user chooses which favourite). In Favourites mode the Fuel + Distance rows
// are hidden — the chosen favourite carries its own fuel, and there is no
// radius when a station is pinned.
struct FuelBoardSmallWidgetConfigurationIntent: WidgetConfigurationIntent, WidgetConfigValues {
    static var title: LocalizedStringResource = "Fuel & Sort"
    static var description = IntentDescription("Which fuel, ordering, radius and pinned favourite this small widget shows.")

    @Parameter(title: "Fuel", default: .e10)
    var fuel: WidgetFuel

    @Parameter(title: "Sort by", default: .cheapest)
    var sort: WidgetSort

    @Parameter(title: "Distance", default: WidgetDistance(id: 5))
    var distance: WidgetDistance

    @Parameter(title: "Favourite", default: WidgetFavourite(fuel: .e10, stationID: ""))
    var favourite: WidgetFavourite

    var favouriteChoice: WidgetFavourite? { favourite }

    static var parameterSummary: some ParameterSummary {
        When(\.$sort, .equalTo, WidgetSort.favourites) {
            Summary("Show \(\.$favourite)") {
                \.$sort
                \.$favourite
            }
        } otherwise: {
            When(\.$sort, .equalTo, WidgetSort.cheapest) {
                Summary("Show \(\.$fuel) by \(\.$sort) within \(\.$distance)") {
                    \.$fuel
                    \.$sort
                    \.$distance
                }
            } otherwise: {
                Summary("Show \(\.$fuel) by \(\.$sort)") {
                    \.$fuel
                    \.$sort
                }
            }
        }
    }
}